Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 8 of 30 Page ID #:44
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`MUST be the MD4 hash [RFC1320] of the data in the chunk, and the block length MUST be
`the number of bytes in the chunk. Because the block length is an unsigned 16-bit integer, all
`chunks MUST be less than or equal to 216-1 bytes in length. Recall that the signatures
`comprise the data in the signature file.”27
`
`MD5 was created shortly after MD4, by the same author. It is an extension of MD4.28 MD4 in
`the RDC system performs the same function as MD5 in claim 16, in the same way, to achieve
`the same result.
`
`On information and belief, Defendants practice claim 17 literally or under the doctrine of
`equivalents by, for example, using DFS Replication and/or SharePoint on systems in their
`internal networks and by inducing their customers to use DFS Replication and/or SharePoint.
`Additionally, HP, Dell, and Acer practice claim 17 by making, using, selling, offering for sale
`and/or licensing systems that use DFS Replication and/or SharePoint. DFS Replication and
`SharePoint use RDC.29
`
`In the DFS Replication context, the sender/computer is in a packet-switched network and
`transmits data to a receiver/computer, e.g.:
`
`“In a typical RDC scenario, a server and a client have different versions of a file. (The terms
`client and server refer only to the computers’ roles in this scenario, not their operating
`systems.)”30
`
` “RDC is suitable for applications that move data across a wide area network (WAN) . . . .”31
`
`[17.] A method for increasing data
`access performed by a
`sender/computer in a packet-
`switched network, said
`sender/computer including an
`operating unit, a first memory, a
`permanent storage memory and a
`processor and said sender/computer
`being operative to transmit principal
`data to a receiver/computer, said
`method comprising the steps of:
`
`
`
`
`27 [MS-RDC] at 19.
`28 RFC 1321: “The MD5 Message-Digest Algorithm” (1992) at 2.
`29 DFS Replication is used herein for exemplary purposes only. SharePoint and other products that use RDC will likewise infringe.
`30 “About Remote Differential Compression” ¶ 12.
`31 “About Remote Differential Compression” ¶ 6.
`
`7
`
`Page 1
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 9 of 30 Page ID #:45
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`creating and transmitting digital
`digests of said principal data and of
`one or more auxiliary data from said
`sender/computer to said
`receiver/computer;
`
`The sender/computer includes an operating unit, a first memory (e.g., RAM), a permanent
`storage memory (e.g., hard disk drive), a processor, and a network cache memory (e.g., has a
`staging folder that is in a network cache memory), e.g.:
`
`“DFS Replication uses staging folders to act as caches for new and changed files to be
`replicated from sending members to receiving members…. The receiving member downloads
`the data and builds the file in its staging folder.”32
`
`The sender/computer creates and transmits a message containing digital digests of principal
`data (e.g., source signature list) to the receiver, e.g.:
`
`“The client initiates the RDC protocol by requesting the source signature list from the server.
`Then the client compares each source signature against the signatures in its own seed signature
`list.”33
`
`“The RDC client and server each use the RDC library’s FilterMax signature generator to
`divide their copy of the file into chunks and compute a strong hash, called a signature, for each
`chunk of file data.”34
`
`“2. Machine B partitions file fB into chunks and computes the signature for each of the chunks.
`Machine B sends its list of chunk signatures, SigB1 ... SigBn, to Machine A. This list provides
`the basis for Machine A being able to reconstruct file fB.”35
`
`“3.2.4.1.10 RdcGetSignatures (Opnum 9)
`The RdcGetSignatures method is used to obtain a file's RDC signature data from the server.”36
`
`
`
`
`32 “Staging Folders and Conflict and Deleted folders” ¶ 1.
`33 “About Remote Differential Compression” ¶ 14.
`34 “About Remote Differential Compression” ¶ 13.
`35 [MS-RDC] at 9.
`
`8
`
`Page 2
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 10 of 30 Page ID #:46
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`
`The sender/computer creates and transmits a message containing digital digests of auxiliary
`data (e.g., similarity data) to the receiver, e.g.:
`
`“3. Using similarity data, as described in section 3.1.5.4, Machine A selects a file fA as a seed
`file and partitions it into chunks. It computes a signature for each chunk, as described in
`section 3.1.5.2.” 37
`
`“To help choose seed files under the circumstances outlined in the preceding paragraph,
`similarity data for new files at the source location are calculated and sent to the target location.
`The similarity data is used on the target location to find existing files that are similar to the
`new source location files.”38
`
`“3.2.4.1.14 InitializeFileTransferAsync (Opnum 13)
`The InitializeFileTransferAsync method is used by a client to start a file download. The client
`supplies an update to specify which file to download. The server provides its latest version of
`the update and initial file contents. The server returns information about the file currently
`being replicated and the first buffer of data from that file (if any).
`. . .
`frsUpdate: The FRS_UPDATE structure that contains information about the file being
`replicated. The fields for the UID in frsUpdate MUST be set to the UID of the file to be
`downloaded. All other fields are cleared (zeroed out) or can have the values provided by the
`server in the response to a RequestUpdates call. On return, all fields of frsUpdate MUST
`contain the values that are held by the server.”39
`
`
`
`
`
`36 [MS-FRS2] at 64.
`37 [MS-RDC] at 9.
`38 [MS-RDC] at 21.
`39 [MS-FRS2] at 71.
`
`9
`
`Page 3
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 11 of 30 Page ID #:47
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`“2.2.1.4.4 FRS_UPDATE
`A structure that contains file metadata related to a particular file being processed by
`Distributed File System Replication (DFS-R).
`. . .
`rdcSimilarity: The similarity hash of the file. The value will be all zeros if the similarity data
`was not computed. See [MS-RDC], 3.1.5.4.”40
`
`The receiver/computer transmits a response signal for the digital digest, containing a positive,
`partial or negative indication signal, e.g.:
`
` “The client initiates the RDC protocol by requesting the source signature list from the server.
`Then the client compares each source signature against the signatures in its own seed signature
`list. If a source signature matches a seed signature, the client already has the file data for that
`signature. If a source signature does not appear in the client's list of seed signatures, the client
`must request the specified chunk (of file data) from the server. . . . The client iterates through
`each needs block and copies the specified chunk of the source or seed file data to the target
`file. Seed file data is copied locally. Source file data is downloaded from the server. The more
`similar the seed and source files are, the less network bandwidth is required to create the target
`file.”41
`
`“5. Machine A sends a request to Machine B for all the chunks whose signatures were received
`in the previous step from Machine B, but that did not have a matching signature on Machine
`A. The chunks are requested by offset and length in file fB based on corresponding information
`that was sent in step 2.”42
`
`
`10
`
`receiving a response signal at said
`sender/computer from said
`receiver/computer, said response
`signal containing a positive, negative
`or partial indication signal, and
`
`
`
`
`40 [MS-FRS2] at 71.
`41 “About Remote Differential Compression” ¶¶ 14, 16.
`42 [MS-RDC] at 9.
`
`Page 4
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 12 of 30 Page ID #:48
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`“3.2.4.1.9 RawGetFileData (Opnum 8)
`The RawGetFileData method is used to transfer successive segments of compressed marshaled
`data for a file from the server to the client.”43
`
`“3.2.4.1.11 RdcPushSourceNeeds (Opnum 10)
`The RdcPushSourceNeeds method is used to register requests for file ranges on a server.”44
`
`“3.2.4.1.12 RdcGetFileData (Opnum 11)
`The RdcGetFileData method is used to obtain file ranges whose requests have previously been
`queued on a server by calling the RdcPushSourceNeeds method.”45
`
`“3.2.4.1.13 RdcClose (Opnum 12)
`The RdcClose method informs the server that the server context information can be
`released.”46
`
`“3.2.4.1.15 RawGetFileDataAsync (Opnum 15)
`The RawGetFileDataAsync method is used instead of calling RawGetFileData multiple times
`to obtain file data. As specified in [MS-RPCE], the specification for asynchronous RPC, an
`RPC client pulls file data from the byte pipe until receiving an end-of-file notification from the
`pipe.”47
`
`“3.2.4.1.16 RdcGetFileDataAsync (Opnum 16)
`The RdcGetFileDataAsync method is used instead of calling RdcGetFileData multiple times to
`obtain file data. As specified in [MS-RPCE], the specification for asynchronous RPC, an RPC
`
`
`
`
`43 [MS-FRS2]: Distributed File System Replication Protocol – v20151016 at 63.
`44 [MS-FRS2] at 66-67.
`45 [MS-FRS2] at 67-68.
`46 [MS-FRS2] at 70.
`47 [MS-FRS2] at 76.
`
`11
`
`Page 5
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 13 of 30 Page ID #:49
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`client pulls file data from the byte pipe until receiving an end-of-file notification from the
`pipe.”48
`
`“A transfer over the RDC protocol starts and finishes similarly to a direct file transfer. The
`client first uses an InitializeFileTransferAsync to establish a context handle for the file, and
`then calls RdcGetSignatures to retrieve the signatures (possibly at recursive levels) that pertain
`to the file being transferred. To retrieve file data at given offsets and lengths, the client uses
`RdcPushSourceNeeds to indicate which data ranges are requested from the file to be
`transferred. Notice that several ranges may be coalesced in a single call to
`RdcPushSourceNeeds.”49
`
`If the receiver/computer sends a partial indication signal, the sender/computer transmits a
`signal constituting the difference between said principal data and corresponding auxiliary data
`to the receiver/computer, e.g.:
`
`“To help choose seed files under the circumstances outlined in the preceding paragraph,
`similarity data for new files at the source location are calculated and sent to the target location.
`The similarity data is used on the target location to find existing files that are similar to the
`new source location files. The existing target location files can then become the seed files for
`an RDC replication of the new source location files, making the transfer of the new files more
`efficient.”50
`
`“Using the similarity data that has been calculated for files on the target location, it may be
`possible to find RDC seed files for files that have been added to the source location but not to
`the target location. Similarity data consists of 16 bytes of data called similarity traits.
`
`
`12
`
`if a partial indication signal is
`received, said sender/computer
`transmitting a signal constituting the
`difference between said principal
`data and corresponding auxiliary
`data.
`
`
`
`
`48 [MS-FRS2] at 77.
`49 [MS-FRS2] at 86.
`50 [MS-RDC] at 21.
`
`Page 6
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 14 of 30 Page ID #:50
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`“When the source location has a new file that requires replication on the target location, the
`application on the source location can send the similarity data of the new file to the target
`location. The application on the target location compares the similarity traits of the new file to
`the similarity traits of each of the target location's existing files, counting the similarity traits
`that are the same (that is, that match). The application can then determine which of the existing
`files are used as seed, based on the number of similarity trait matches; for example, based on a
`threshold or a majority scheme.”51
`
`“The client initiates the RDC protocol by requesting the source signature list from the server.
`Then the client compares each source signature against the signatures in its own seed signature
`list. If a source signature matches a seed signature, the client already has the file data for that
`signature. If a source signature does not appear in the client's list of seed signatures, the client
`must request the specified chunk (of file data) from the server. . . . The client iterates through
`each needs block and copies the specified chunk of the source or seed file data to the target
`file. Seed file data is copied locally. Source file data is downloaded from the server. The more
`similar the seed and source files are, the less network bandwidth is required to create the target
`file.”52
`
`“6. Machine B sends the contents of the requested chunks to Machine A.”53
`
`“3.2.4.1.11 RdcPushSourceNeeds (Opnum 10)
`The RdcPushSourceNeeds method is used to register requests for file ranges on a server.
`. . .
`Actions Triggered: Upon successfully validating the RDC source needs request, the server
`queues up the requested file offset/length pairs, also known as RDC source needs. The number
`of RDC source needs queued by the server MUST NOT exceed the value of
`
`
`
`
`51 [MS-RDC] at 23.
`52 “About Remote Differential Compression” ¶¶ 14, 16.
`53 [MS-RDC] at 9.
`
`13
`
`Page 7
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 15 of 30 Page ID #:51
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`CONFIG_RDC_NEED_QUEUE_SIZE. The client MAY send multiple RdcPushSourceNeeds
`requests. If the server receives a request that causes the total number of RDC source needs
`already in the queue plus the value of the needCount parameter to be greater than the value of
`CONFIG_RDC_NEED_QUEUE_SIZE, then the server MUST fail the request with an
`implementation-defined failure value.
`The server uses the queued RDC source needs to form a stream of data from the marshaled
`source file. The format of this data stream is specified in section 3.2.4.1.12 and is returned in
`the buffer supplied by the RdcGetFileData method or the RdcGetFileDataAsync method.”54
`
`“3.2.4.1.12 RdcGetFileData (Opnum 11)
`The RdcGetFileData method is used to obtain file ranges whose requests have previously been
`queued on a server by calling the RdcPushSourceNeeds method.”55
`
`The digital digest is obtained from the permanent storage memory of the sender computer,
`e.g.”
`
`“Cross-file RDC takes this further by using special hidden sparse files (located in
`<drive>:\system volume information\dfsr\similaritytable_x and idrecordtable_x) to track all
`these signatures. With them, DFSR can use other similar files that the server already has to
`build a copy of a new file locally. DFSR can use up to five of these similar files.”56
`
`[20.] The method as claimed in
`claim 17, wherein said digital digest
`is obtained from the permanent
`storage memory of said
`sender/computer.
`
`
`
`
`54 [MS-FRS2] at 66-67.
`55 [MS-FRS2] at 67-68.
`56 “DFS Replication in Windows Server 2012 R2: Revenge of the Sync” (July 31, 2013) available at:
`https://blogs.technet.microsoft.com/filecab/2013/07/31/dfs-replication-in-windows-server-2012-r2-revenge-of-the-sync/
`
`14
`
`Page 8
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 16 of 30 Page ID #:52
`
`Claim Language
`
`[22.] A method for increased data
`access performed by a
`receiver/computer in a packet-
`switched network, said
`receiver/computer including an
`operating unit, a first memory, a
`permanent storage memory, a
`processor and a network cache
`memory, said method comprising
`the steps of:
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`“Step S.1.2: S replies with the set of traits for FS, Traits(FS). Traits(FS) will be usually
`cached as part of the metadata of FS, and thus can be sent to C without additional
`
`
`
`overhead.”57
`
`On information and belief, Defendants practice claim 24 (which depends on claim 22) literally
`or under the doctrine of equivalents by, for example, using DFS Replication and/or SharePoint
`on systems in their internal networks and by inducing their customers to use DFS Replication
`and/or SharePoint. Additionally, HP, Dell, and Acer practice claim 24 by making, using,
`selling, offering for sale and/or licensing systems that use DFS Replication and/or SharePoint.
`DFS Replication and SharePoint use RDC.58
`
`In the DFS Replication context, the receiver/computer is in a packet-switched network, e.g.:
`
`“In a typical RDC scenario, a server and a client have different versions of a file. (The terms
`client and server refer only to the computers’ roles in this scenario, not their operating
`systems.)”59
`
` “RDC is suitable for applications that move data across a wide area network (WAN) . . . .”60
`
`The receiver/computer includes an operating unit, a first memory (e.g., RAM), a permanent
`storage memory (e.g., hard disk drive), a processor, and a network cache memory (e.g., has a
`staging folder that is in a network cache memory), e.g.:
`
`“DFS Replication uses staging folders to act as caches for new and changed files to be
`
`
`
`
`57 D. Teodosiu, et al., “Optimizing File Replication over Limited-Bandwidth Networks using Remote Differential Compression”
`(2006) at 5, available at: http://research.microsoft.com/apps/pubs/default.aspx?id=64692
`58 DFS Replication is used herein for exemplary purposes only. SharePoint and other products that use RDC will likewise infringe.
`59 “About Remote Differential Compression” ¶ 12.
`60 “About Remote Differential Compression” ¶ 6.
`
`15
`
`Page 9
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 17 of 30 Page ID #:53
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`replicated from sending members to receiving members…. The receiving member downloads
`the data and builds the file in its staging folder.”61
`
`receiving a message containing a
`digital digest from said network;
`
`The receiver/computer receives a message containing digital digests (e.g., signatures) from the
`network, e.g.:
`
`“The client initiates the RDC protocol by requesting the source signature list from the server.
`Then the client compares each source signature against the signatures in its own seed signature
`list.”62
`
`“The RDC client and server each use the RDC library’s FilterMax signature generator to
`divide their copy of the file into chunks and compute a strong hash, called a signature, for each
`chunk of file data.”63
`
`“2. Machine B partitions file fB into chunks and computes the signature for each of the chunks.
`Machine B sends its list of chunk signatures, SigB1 ... SigBn, to Machine A. This list provides
`the basis for Machine A being able to reconstruct file fB.”64
`
`“3.2.4.1.10 RdcGetSignatures (Opnum 9)
`The RdcGetSignatures method is used to obtain a file's RDC signature data from the server.”65
`
`The receiver/computer searches for data with the same digital digest in the network cache
`memory (e.g., by consulting its own signature list for data with the same signature), e.g.:
`
`“The client initiates the RDC protocol by requesting the source signature list from the server.
`
`searching for data with the same
`digital digest in said network cache
`memory,
`
`
`
`
`61 “Staging Folders and Conflict and Deleted folders” ¶ 1.
`62 “About Remote Differential Compression” ¶ 14.
`63 “About Remote Differential Compression” ¶ 13.
`64 [MS-RDC] at 9.
`65 [MS-FRS2] at 64.
`
`16
`
`Page 10
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 18 of 30 Page ID #:54
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`Then the client compares each source signature against the signatures in its own seed signature
`list.”66
`
`“4. As Machine A receives the chunk signatures from Machine B, it compares the received
`signatures against the set of signatures SigA1, ..., SigAm that it has computed on its seed file
`(that is, file fA) in step 2. As part of this comparison, Machine A records every distinct
`signature value it received from Machine B that does not match one of its own signatures
`SigAk computed on the chunks of file fA.”67
`If the receiver/computer does not locate data having the same digital digest (e.g., signature), it
`forms a negative indication signal and transmits it back through the network (e.g., requests that
`the file be sent to it), e.g.:
`
`“The client initiates the RDC protocol by requesting the source signature list from the server.
`Then the client compares each source signature against the signatures in its own seed signature
`list. If a source signature matches a seed signature, the client already has the file data for that
`signature. If a source signature does not appear in the client's list of seed signatures, the client
`must request the specified chunk (of file data) from the server. . . . The client iterates through
`each needs block and copies the specified chunk of the source or seed file data to the target
`file. Seed file data is copied locally. Source file data is downloaded from the server. The more
`similar the seed and source files are, the less network bandwidth is required to create the target
`file.”68
`
`“5. Machine A sends a request to Machine B for all the chunks whose signatures were received
`in the previous step from Machine B, but that did not have a matching signature on Machine
`
`17
`
`if data having the same digital digest
`as the digital digest received is not
`uncovered, forming a negative
`indication signal and transmitting it
`back through said network; and
`
`
`
`
`66 “About Remote Differential Compression” ¶ 14.
`67 [MS-RDC] at 9.
`68 “About Remote Differential Compression” ¶¶ 14, 16.
`
`Page 11
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 19 of 30 Page ID #:55
`
`Claim Language
`
`creating a digital digest for data
`received from said network cache
`memory.
`
`
`
`
`69 [MS-RDC] at 9.
`70 [MS-FRS2] at 66-67.
`71 [MS-FRS2] at 67-68.
`72 [MS-FRS2] at 86.
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`A. The chunks are requested by offset and length in file fB based on corresponding information
`that was sent in step 2.”69
`
`“3.2.4.1.11 RdcPushSourceNeeds (Opnum 10)
`The RdcPushSourceNeeds method is used to register requests for file ranges on a server.”70
`
`“3.2.4.1.12 RdcGetFileData (Opnum 11)
`The RdcGetFileData method is used to obtain file ranges whose requests have previously been
`queued on a server by calling the RdcPushSourceNeeds method.”71
`
`“A transfer over the RDC protocol starts and finishes similarly to a direct file transfer. The
`client first uses an InitializeFileTransferAsync to establish a context handle for the file, and
`then calls RdcGetSignatures to retrieve the signatures (possibly at recursive levels) that pertain
`to the file being transferred. To retrieve file data at given offsets and lengths, the client uses
`RdcPushSourceNeeds to indicate which data ranges are requested from the file to be
`transferred. Notice that several ranges may be coalesced in a single call to
`RdcPushSourceNeeds.”72
`
`The receiver/computer creates a digital digest for data received from the network cache
`memory, for example, by using the FilterMax signature generator to create a signature of the
`
`18
`
`Page 12
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 20 of 30 Page ID #:56
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`file from its staging folders:
`
`“The RDC client and server each use the RDC library’s FilterMax signature generator to
`divide their copy of the file into chunks and compute a strong hash, called a signature, for each
`chunk of file data.”73
`
`“DFS Replication uses staging folders to act as caches for new and changed files to be
`replicated from sending members to receiving members…. The receiving member downloads
`the data and builds the file in its staging folder.”74
`
`The digital digests for different data objects are received in the same message and an
`indication signal is generated separately for each of said data objects:
`
` “The client initiates the RDC protocol by requesting the source signature list from the server.
`Then the client compares each source signature against the signatures in its own seed signature
`list. If a source signature matches a seed signature, the client already has the file data for that
`signature. If a source signature does not appear in the client's list of seed signatures, the client
`must request the specified chunk (of file data) from the server.
`
`“The result of comparing the two signature lists is a needs list, which describes which chunks
`of file data, from where (seed or source file), are needed to construct the target file on the
`client computer. Each entry in the needs list is called a needs block.
`
`“The client iterates through each needs block and copies the specified chunk of the source or
`seed file data to the target file. Seed file data is copied locally. Source file data is downloaded
`from the server. The more similar the seed and source files are, the less network bandwidth is
`required to create the target file.”75
`
`19
`
`[24.] The method as claimed in
`claim 22, wherein a plurality of
`digital digests for different data
`objects is received in the same
`message and an indication signal is
`generated separately for each of said
`data objects.
`
`
`
`
`73 “About Remote Differential Compression” ¶ 13.
`74 “Staging Folders and Conflict and Deleted folders” ¶ 1.
`75 “About Remote Differential Compression” ¶¶ 14-16.
`
`Page 13
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 21 of 30 Page ID #:57
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`On information and belief, Defendants practice claim 25 literally or under the doctrine of
`equivalents by, for example, using DFS Replication and/or SharePoint on systems in their
`internal networks and by inducing their customers to use DFS Replication and/or SharePoint.
`Additionally, HP, Dell, and Acer practice claim 25 by making, using, selling, offering for sale
`and/or licensing systems that use DFS Replication and/or SharePoint. DFS Replication and
`SharePoint use RDC.76
`
`In the DFS Replication context, the receiver/computer is in a packet-switched network, e.g.:
`
`“In a typical RDC scenario, a server and a client have different versions of a file. (The terms
`client and server refer only to the computers’ roles in this scenario, not their operating
`systems.)”77
`
` “RDC is suitable for applications that move data across a wide area network (WAN) . . . .”78
`
`The receiver/computer includes an operating unit, a first memory (e.g., RAM), a permanent
`storage memory (e.g., hard disk drive), a processor, and a network cache memory (e.g., has a
`staging folder that is in a network cache memory), e.g.:
`
`“DFS Replication uses staging folders to act as caches for new and changed files to be
`replicated from sending members to receiving members…. The receiving member downloads
`the data and builds the file in its staging folder.”79
`
`The receiver/computer receives a message containing a principal digital digest (e.g., source
`signature list) from the network, e.g.:
`
`76 DFS Replication is used herein for exemplary purposes only. SharePoint and other products that use RDC will likewise infringe.
`77 “About Remote Differential Compression” ¶ 12.
`78 “About Remote Differential Compression” ¶ 6.
`79 “Staging Folders and Conflict and Deleted folders” ¶ 1.
`
`20
`
`[25.] A method for increased data
`access performed by a
`receiver/computer in a packet-
`switched network, said
`receiver/computer including an
`operating unit, a first memory, a
`permanent storage memory, a
`processor and a network cache
`memory, said method comprising
`the steps of:
`
`receiving a message containing a
`principal digital digest and one or
`more auxiliary digital digests from
`
`
`
`
`Page 14
`
`

`
`Case 8:16-cv-01102 Document 1-2 Filed 06/14/16 Page 22 of 30 Page ID #:58
`
`Claim Language
`
`How Practiced by Defendants’ Systems Using Microsoft’s Distributed File System (“DFS”)
`Replication or SharePoint and Remote Differential Compression (“RDC”)1
`
`said network, wherein said auxiliary
`digital digests are correlated to data
`objects similar to the data object
`represented by said principal digest;
`
`“The client initiates the RDC protocol by requesting the source signature list from the server.
`Then the client compares each source signature against the signatures in its own seed signature
`list.”80
`
`“The RDC client and server each use the RDC library’s FilterMax signature generator to
`divide their copy of the file into chunks and compute a strong hash, called a signature, for each
`chunk of file data.”81
`
`“2. Machine B partitions file fB into chunks and computes the signature for each of the chunks.
`Machine B sends its list of chunk signatures, SigB1 ... SigBn, to Machine A. This list provides
`the basis for Machine A being able to reconstruct file fB.”82
`
`“3.2.4.1.10 RdcGetSignatures (Opnum 9)
`The RdcGetSignatures method is used to obtain a file's RDC signature data from the server.”83
`
`The sender/computer creates and transmits a message containing auxiliary digital digests (e.g.,
`similarity data) correlated to data objects similar to the data object represented by said
`principal digest to the receiver, e.g.:
`
`“3. Using similarity data, as described in section 3.1.5.4, Machine A selects a file fA as a seed
`file and partitions it into chunks. It computes a signature for each chunk, as described in
`section 3.1.5.2.” 84
`
`“3.2.4.1.14 InitializeFileTransferAsync (Opnum 13)
`
`
`
`
`80 “About Remote Differential Compression” ¶ 14.
`81