f9f61ff28ca88c0fe69a1163a01f6d60c765d225
galt
  Sat Aug 27 15:46:58 2011 -0700
make udcRead support bit64 request size instead of int
diff --git src/lib/udc.c src/lib/udc.c
index 22aacf7..36d4deb 100644
--- src/lib/udc.c
+++ src/lib/udc.c
@@ -1169,31 +1169,31 @@
     return;
 
 /* Update file startData/endData members to include new data (and old as well if
  * the new data overlaps the old). */
 if (rangeIntersectOrTouch64(file->startData, file->endData, fetchedStart, fetchedEnd))
     {
     if (fetchedStart > file->startData)
         fetchedStart = file->startData;
     if (fetchedEnd < file->endData)
         fetchedEnd = file->endData;
     }
 file->startData = fetchedStart;
 file->endData = fetchedEnd;
 }
 
-static boolean udcCachePreload(struct udcFile *file, bits64 offset, int size)
+static boolean udcCachePreload(struct udcFile *file, bits64 offset, bits64 size)
 /* Make sure that given data is in cache - fetching it remotely if need be. 
  * Return TRUE on success. */
 {
 boolean ok = TRUE;
 /* We'll break this operation into blocks of a reasonable size to allow
  * other processes to get cache access, since we have to lock the cache files. */
 bits64 s,e, endPos=offset+size;
 for (s = offset; s < endPos; s = e)
     {
     /* Figure out bounds of this section. */
     e = s + udcMaxBytesPerRemoteFetch;
     if (e > endPos)
 	e = endPos;
 
     struct udcBitmap *bits = file->bits;
@@ -1202,60 +1202,60 @@
         udcFetchMissing(file, bits, s, e);
 	}
     else
 	{
 	ok = FALSE;
 	verbose(2, "udcCachePreload version check failed %d vs %d", 
 		bits->version, file->bitmapVersion);
 	}
     if (!ok)
         break;
     }
 return ok;
 }
 
 #define READAHEADBUFSIZE 4096
-int udcRead(struct udcFile *file, void *buf, int size)
+bits64 udcRead(struct udcFile *file, void *buf, bits64 size)
 /* Read a block from file.  Return amount actually read. */
 {
 
 /* Figure out region of file we're going to read, and clip it against file size. */
 bits64 start = file->offset;
 if (start > file->size)
     return 0;
 bits64 end = start + size;
 if (end > file->size)
     end = file->size;
 size = end - start;
 char *cbuf = buf;
 
 /* use read-ahead buffer if present */
-int bytesRead = 0;
+bits64 bytesRead = 0;
 
 bits64 raStart;
 bits64 raEnd;
 while(TRUE)
     {
     if (file->sparseReadAhead)
 	{
 	raStart = file->sparseRAOffset;
 	raEnd = raStart+READAHEADBUFSIZE;
 	if (start >= raStart && start < raEnd)
 	    {
 	    // copy bytes out of rabuf
-	    int endInBuf = min(raEnd, end);
-	    int sizeInBuf = endInBuf - start;
+	    bits64 endInBuf = min(raEnd, end);
+	    bits64 sizeInBuf = endInBuf - start;
 	    memcpy(cbuf, file->sparseReadAheadBuf + (start-raStart), sizeInBuf);
 	    cbuf += sizeInBuf;
 	    bytesRead += sizeInBuf;
 	    start = raEnd;
 	    size -= sizeInBuf;
 	    file->offset += sizeInBuf;
 	    if (size == 0)
 		break;
 	    }
 	file->sparseReadAhead = FALSE;
 	mustLseek(file->fdSparse, start, SEEK_SET);
 	}
 
     bits64 saveEnd = end;
     if (size < READAHEADBUFSIZE)
@@ -1299,36 +1299,36 @@
 	end = saveEnd;
 	size = end - start;
 	}
     else
 	{
 	mustReadFd(file->fdSparse, cbuf, size);
 	file->offset += size;
 	bytesRead += size;
 	break;
 	}
     }
 
 return bytesRead;
 }
 
-void udcMustRead(struct udcFile *file, void *buf, int size)
+void udcMustRead(struct udcFile *file, void *buf, bits64 size)
 /* Read a block from file.  Abort if any problem, including EOF before size is read. */
 {
-int sizeRead = udcRead(file, buf, size);
+bits64 sizeRead = udcRead(file, buf, size);
 if (sizeRead < size)
-    errAbort("udc couldn't read %d bytes from %s, did read %d", size, file->url, sizeRead);
+    errAbort("udc couldn't read %llu bytes from %s, did read %llu", size, file->url, sizeRead);
 }
 
 int udcGetChar(struct udcFile *file)
 /* Get next character from file or die trying. */
 {
 UBYTE b;
 udcMustRead(file, &b, 1);
 return b;
 }
 
 bits64 udcReadBits64(struct udcFile *file, boolean isSwapped)
 /* Read and optionally byte-swap 64 bit entity. */
 {
 bits64 val;
 udcMustRead(file, &val, sizeof(val));