You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@trafficserver.apache.org by jp...@apache.org on 2010/05/19 23:06:42 UTC

svn commit: r946395 [3/8] - in /trafficserver/traffic/trunk: example/app-template/ iocore/aio/ iocore/block-cache/ iocore/cache/ iocore/cluster/ iocore/dns/ iocore/eventsystem/ iocore/hostdb/ iocore/hostdb/include/ iocore/net/ iocore/utils/ libinktomi+...

Modified: trafficserver/traffic/trunk/iocore/cluster/P_ClusterInternal.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/cluster/P_ClusterInternal.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/cluster/P_ClusterInternal.h (original)
+++ trafficserver/traffic/trunk/iocore/cluster/P_ClusterInternal.h Wed May 19 21:06:35 2010
@@ -129,11 +129,11 @@
 #define WRITE_MESSAGE_ALREADY_BUILT -1
 
 #define MAGIC_COUNT(_x) \
-(0xBADBAD ^ ~(inku32)_x.msg.count \
- ^ ~(inku32)_x.msg.descriptor_cksum \
- ^ ~(inku32)_x.msg.control_bytes_cksum \
- ^ ~(inku32)_x.msg.unused \
- ^ ~((inku32)_x.msg.control_bytes << 16) ^_x.sequence_number)
+(0xBADBAD ^ ~(uint32)_x.msg.count \
+ ^ ~(uint32)_x.msg.descriptor_cksum \
+ ^ ~(uint32)_x.msg.control_bytes_cksum \
+ ^ ~(uint32)_x.msg.unused \
+ ^ ~((uint32)_x.msg.control_bytes << 16) ^_x.sequence_number)
 
 #define DOUBLE_ALIGN(_x)    ((((unsigned long)_x)+7)&~7)
 
@@ -221,10 +221,10 @@ struct enter_exit_class
 //
 struct CloseMessage:public ClusterMessageHeader
 {
-  inku32 channel;
-  ink32 status;
-  ink32 lerrno;
-  inku32 sequence_number;
+  uint32 channel;
+  int32 status;
+  int32 lerrno;
+  uint32 sequence_number;
 
   enum
   {
@@ -233,7 +233,7 @@ struct CloseMessage:public ClusterMessag
     CLOSE_CHAN_MESSAGE_VERSION = MAX_VERSION
   };
 
-    CloseMessage(inku16 vers = CLOSE_CHAN_MESSAGE_VERSION)
+    CloseMessage(uint16 vers = CLOSE_CHAN_MESSAGE_VERSION)
 :  ClusterMessageHeader(vers), channel(0), status(0), lerrno(0), sequence_number(0) {
   }
   ////////////////////////////////////////////////////////////////////////////
@@ -246,15 +246,15 @@ struct CloseMessage:public ClusterMessag
   {
     return sizeof(CloseMessage);
   }
-  void init(inku16 vers = CLOSE_CHAN_MESSAGE_VERSION) {
+  void init(uint16 vers = CLOSE_CHAN_MESSAGE_VERSION) {
     _init(vers);
   }
   inline void SwapBytes()
   {
     if (NeedByteSwap()) {
       swap32(&channel);
-      swap32((inku32 *) & status);
-      swap32((inku32 *) & lerrno);
+      swap32((uint32 *) & status);
+      swap32((uint32 *) & lerrno);
       swap32(&sequence_number);
     }
   }
@@ -266,8 +266,8 @@ struct CloseMessage:public ClusterMessag
 //
 struct MachineListMessage:public ClusterMessageHeader
 {
-  inku32 n_ip;                  // Valid entries in ip[]
-  inku32 ip[CLUSTER_MAX_MACHINES];      // variable length data
+  uint32 n_ip;                  // Valid entries in ip[]
+  uint32 ip[CLUSTER_MAX_MACHINES];      // variable length data
 
   enum
   {
@@ -290,7 +290,7 @@ struct MachineListMessage:public Cluster
   {
     return sizeof(ClusterMessageHeader);
   }
-  void init(inku16 vers = MACHINE_LIST_MESSAGE_VERSION) {
+  void init(uint16 vers = MACHINE_LIST_MESSAGE_VERSION) {
     _init(vers);
   }
   inline void SwapBytes()
@@ -305,9 +305,9 @@ struct MachineListMessage:public Cluster
 //
 struct SetChanDataMessage:public ClusterMessageHeader
 {
-  inku32 channel;
-  inku32 sequence_number;
-  inku32 data_type;             // enum CacheDataType
+  uint32 channel;
+  uint32 sequence_number;
+  uint32 data_type;             // enum CacheDataType
   char data[4];
 
   enum
@@ -317,7 +317,7 @@ struct SetChanDataMessage:public Cluster
     SET_CHANNEL_DATA_MESSAGE_VERSION = MAX_VERSION
   };
 
-    SetChanDataMessage(inku16 vers = SET_CHANNEL_DATA_MESSAGE_VERSION)
+    SetChanDataMessage(uint16 vers = SET_CHANNEL_DATA_MESSAGE_VERSION)
 :  ClusterMessageHeader(vers), channel(0), sequence_number(0), data_type(0) {
     memset(data, 0, sizeof(data));
   }
@@ -330,9 +330,9 @@ struct SetChanDataMessage:public Cluster
   static int sizeof_fixedlen_msg()
   {
     SetChanDataMessage *p = 0;
-    return (int) DOUBLE_ALIGN((ink64) ((char *) &p->data[0] - (char *) p));
+    return (int) DOUBLE_ALIGN((int64) ((char *) &p->data[0] - (char *) p));
   }
-  void init(inku16 vers = SET_CHANNEL_DATA_MESSAGE_VERSION) {
+  void init(uint16 vers = SET_CHANNEL_DATA_MESSAGE_VERSION) {
     _init(vers);
   }
   inline void SwapBytes()
@@ -351,9 +351,9 @@ struct SetChanDataMessage:public Cluster
 //
 struct SetChanPinMessage:public ClusterMessageHeader
 {
-  inku32 channel;
-  inku32 sequence_number;
-  inku32 pin_time;
+  uint32 channel;
+  uint32 sequence_number;
+  uint32 pin_time;
 
   enum
   {
@@ -362,7 +362,7 @@ struct SetChanPinMessage:public ClusterM
     SET_CHANNEL_PIN_MESSAGE_VERSION = MAX_VERSION
   };
 
-    SetChanPinMessage(inku16 vers = SET_CHANNEL_PIN_MESSAGE_VERSION)
+    SetChanPinMessage(uint16 vers = SET_CHANNEL_PIN_MESSAGE_VERSION)
 :  ClusterMessageHeader(vers), channel(0), sequence_number(0), pin_time(0) {
   }
   ////////////////////////////////////////////////////////////////////////////
@@ -375,7 +375,7 @@ struct SetChanPinMessage:public ClusterM
   {
     return (int) sizeof(SetChanPinMessage);
   }
-  void init(inku16 vers = SET_CHANNEL_PIN_MESSAGE_VERSION) {
+  void init(uint16 vers = SET_CHANNEL_PIN_MESSAGE_VERSION) {
     _init(vers);
   }
   inline void SwapBytes()
@@ -394,9 +394,9 @@ struct SetChanPinMessage:public ClusterM
 //
 struct SetChanPriorityMessage:public ClusterMessageHeader
 {
-  inku32 channel;
-  inku32 sequence_number;
-  inku32 disk_priority;
+  uint32 channel;
+  uint32 sequence_number;
+  uint32 disk_priority;
 
   enum
   {
@@ -405,7 +405,7 @@ struct SetChanPriorityMessage:public Clu
     SET_CHANNEL_PRIORITY_MESSAGE_VERSION = MAX_VERSION
   };
 
-    SetChanPriorityMessage(inku16 vers = SET_CHANNEL_PRIORITY_MESSAGE_VERSION)
+    SetChanPriorityMessage(uint16 vers = SET_CHANNEL_PRIORITY_MESSAGE_VERSION)
 :  ClusterMessageHeader(vers), channel(0), sequence_number(0), disk_priority(0) {
   }
   ////////////////////////////////////////////////////////////////////////////
@@ -418,7 +418,7 @@ struct SetChanPriorityMessage:public Clu
   {
     return (int) sizeof(SetChanPriorityMessage);
   }
-  void init(inku16 vers = SET_CHANNEL_PRIORITY_MESSAGE_VERSION) {
+  void init(uint16 vers = SET_CHANNEL_PRIORITY_MESSAGE_VERSION) {
     _init(vers);
   }
   inline void SwapBytes()

Modified: trafficserver/traffic/trunk/iocore/cluster/P_ClusterMachine.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/cluster/P_ClusterMachine.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/cluster/P_ClusterMachine.h (original)
+++ trafficserver/traffic/trunk/iocore/cluster/P_ClusterMachine.h Wed May 19 21:06:35 2010
@@ -74,8 +74,8 @@ struct ClusterMachine:Server
    ~ClusterMachine();
 
   // Cluster message protocol version
-  inku16 msg_proto_major;
-  inku16 msg_proto_minor;
+  uint16 msg_proto_major;
+  uint16 msg_proto_minor;
 
   // Private data for ClusterProcessor
   //

Modified: trafficserver/traffic/trunk/iocore/dns/DNS.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/dns/DNS.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/dns/DNS.cc (original)
+++ trafficserver/traffic/trunk/iocore/dns/DNS.cc Wed May 19 21:06:35 2010
@@ -83,9 +83,9 @@ strnchr(char *s, char c, int len)
   return *s == c ? s : (char *) NULL;
 }
 
-static inline inku16
-ink_get16(const inku8 *src) {
-  inku16 dst;
+static inline uint16
+ink_get16(const uint8 *src) {
+  uint16 dst;
 
   NS_GET16(dst, src);
   return dst;
@@ -152,7 +152,7 @@ DNSProcessor::open(unsigned int aip, int
 void
 DNSProcessor::dns_init()
 {
-  ink64 sval, cval = 0;
+  int64 sval, cval = 0;
 
   DNS_READ_DYN_STAT(dns_sequence_number_stat, sval, cval);
 
@@ -1207,7 +1207,7 @@ dns_process(DNSHandler * handler, HostEn
   DNSEntry *e = get_dns(handler, (u_short) ntohs(h->id));
   bool retry = false;
   bool server_ok = true;
-  inku32 temp_ttl = 0;
+  uint32 temp_ttl = 0;
 
   //
   // Do we have an entry for this id?

Modified: trafficserver/traffic/trunk/iocore/dns/I_DNSProcessor.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/dns/I_DNSProcessor.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/dns/I_DNSProcessor.h (original)
+++ trafficserver/traffic/trunk/iocore/dns/I_DNSProcessor.h Wed May 19 21:06:35 2010
@@ -51,7 +51,7 @@
 struct HostEnt
 {
   struct hostent ent;
-  inku32 ttl;
+  uint32 ttl;
   int ref_count;
   int packet_size;
   char buf[MAX_DNS_PACKET_LEN];

Modified: trafficserver/traffic/trunk/iocore/dns/P_SplitDNSProcessor.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/dns/P_SplitDNSProcessor.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/dns/P_SplitDNSProcessor.h (original)
+++ trafficserver/traffic/trunk/iocore/dns/P_SplitDNSProcessor.h Wed May 19 21:06:35 2010
@@ -143,7 +143,7 @@ struct SplitDNS:public SplitDNSConfigInf
   DNS_table *m_DNSSrvrTable;
   SplitDNSRecord *m_DefaultDNSSrvr;
 
-  ink32 m_SplitDNSlEnable;
+  int32 m_SplitDNSlEnable;
 
   char m_def_domain[MAXDNAME];
   int m_def_domain_len;

Modified: trafficserver/traffic/trunk/iocore/dns/SRV.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/dns/SRV.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/dns/SRV.cc (original)
+++ trafficserver/traffic/trunk/iocore/dns/SRV.cc Wed May 19 21:06:35 2010
@@ -72,7 +72,7 @@ SRVHosts::getWeightedHost(char *ret_val)
   int tmp[1024];
   int j = 0;
   int v;
-  inku32 xx;
+  uint32 xx;
 
   if (hosts.empty() || getCount() == 0) {
     goto err;

Modified: trafficserver/traffic/trunk/iocore/eventsystem/IOBuffer.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/IOBuffer.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/IOBuffer.cc (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/IOBuffer.cc Wed May 19 21:06:35 2010
@@ -36,9 +36,9 @@ inkcoreapi Allocator ioBufAllocator[DEFA
 inkcoreapi ClassAllocator<MIOBuffer> ioAllocator("ioAllocator", DEFAULT_BUFFER_NUMBER);
 inkcoreapi ClassAllocator<IOBufferData> ioDataAllocator("ioDataAllocator", DEFAULT_BUFFER_NUMBER);
 inkcoreapi ClassAllocator<IOBufferBlock> ioBlockAllocator("ioBlockAllocator", DEFAULT_BUFFER_NUMBER);
-ink64 default_large_iobuffer_size = DEFAULT_LARGE_BUFFER_SIZE;
-ink64 default_small_iobuffer_size = DEFAULT_SMALL_BUFFER_SIZE;
-ink64 max_iobuffer_size = DEFAULT_BUFFER_SIZES - 1;
+int64 default_large_iobuffer_size = DEFAULT_LARGE_BUFFER_SIZE;
+int64 default_small_iobuffer_size = DEFAULT_SMALL_BUFFER_SIZE;
+int64 max_iobuffer_size = DEFAULT_BUFFER_SIZES - 1;
 
 //
 // Initialization
@@ -49,8 +49,8 @@ init_buffer_allocators()
   char *name;
 
   for (int i = 0; i < DEFAULT_BUFFER_SIZES; i++) {
-    ink64 s = DEFAULT_BUFFER_BASE_SIZE * (((ink64)1) << i);
-    ink64 a = DEFAULT_BUFFER_ALIGNMENT;
+    int64 s = DEFAULT_BUFFER_BASE_SIZE * (((int64)1) << i);
+    int64 a = DEFAULT_BUFFER_ALIGNMENT;
     int n = i <= default_large_iobuffer_size ? DEFAULT_BUFFER_NUMBER : DEFAULT_HUGE_BUFFER_NUMBER;
     if (s < a)
       a = s;
@@ -61,10 +61,10 @@ init_buffer_allocators()
   }
 }
 
-ink64
+int64
 MIOBuffer::remove_append(IOBufferReader * r)
 {
-  ink64 l = 0;
+  int64 l = 0;
   while (r->block) {
     Ptr<IOBufferBlock> b = r->block;
     r->block = r->block->next;
@@ -81,15 +81,15 @@ MIOBuffer::remove_append(IOBufferReader 
   return l;
 }
 
-ink64
-MIOBuffer::write(const void *abuf, ink64 alen)
+int64
+MIOBuffer::write(const void *abuf, int64 alen)
 {
   const char *buf = (const char*)abuf;
-  ink64 len = alen;
+  int64 len = alen;
   while (len) {
     if (!_writer)
       add_block();
-    ink64 f = _writer->write_avail();
+    int64 f = _writer->write_avail();
     f = f < len ? f : len;
     if (f > 0) {
       ::memcpy(_writer->end(), buf, f);
@@ -115,10 +115,10 @@ MIOBuffer::write(const void *abuf, ink64
    * and this space becomes available to the copy.
    *
    */
-ink64
-MIOBuffer::write_and_transfer_left_over_space(IOBufferReader * r, ink64 alen, ink64 offset)
+int64
+MIOBuffer::write_and_transfer_left_over_space(IOBufferReader * r, int64 alen, int64 offset)
 {
-  ink64 rval = write(r, alen, offset);
+  int64 rval = write(r, alen, offset);
   // reset the end markers of the original so that it cannot
   // make use of the space in the current block
   if (r->mbuf->_writer)
@@ -134,22 +134,22 @@ MIOBuffer::write_and_transfer_left_over_
 #endif
 
 
-ink64
-MIOBuffer::write(IOBufferReader * r, ink64 alen, ink64 offset)
+int64
+MIOBuffer::write(IOBufferReader * r, int64 alen, int64 offset)
 {
-  ink64 len = alen;
+  int64 len = alen;
   IOBufferBlock *b = r->block;
   offset += r->start_offset;
 
   while (b && len > 0) {
-    ink64 max_bytes = b->read_avail();
+    int64 max_bytes = b->read_avail();
     max_bytes -= offset;
     if (max_bytes <= 0) {
       offset = -max_bytes;
       b = b->next;
       continue;
     }
-    ink64 bytes;
+    int64 bytes;
     if (len<0 || len>= max_bytes)
       bytes = max_bytes;
     else
@@ -165,8 +165,8 @@ MIOBuffer::write(IOBufferReader * r, ink
   return alen - len;
 }
 
-ink64
-MIOBuffer::puts(char *s, ink64 len)
+int64
+MIOBuffer::puts(char *s, int64 len)
 {
   char *pc = end();
   char *pb = s;
@@ -174,7 +174,7 @@ MIOBuffer::puts(char *s, ink64 len)
     if (len-- <= 0)
       return -1;
     if (!*pb || *pb == '\n') {
-      ink64 n = (ink64) (pb - s);
+      int64 n = (int64) (pb - s);
       memcpy(end(), s, n + 1);  // Upto and including '\n'
       end()[n + 1] = 0;
       fill(n + 1);
@@ -186,16 +186,16 @@ MIOBuffer::puts(char *s, ink64 len)
   return 0;
 }
 
-ink64
-IOBufferReader::read(void *ab, ink64 len)
+int64
+IOBufferReader::read(void *ab, int64 len)
 {
   char *b = (char*)ab;
-  ink64 max_bytes = read_avail();
-  ink64 bytes = len <= max_bytes ? len : max_bytes;
-  ink64 n = bytes;
+  int64 max_bytes = read_avail();
+  int64 bytes = len <= max_bytes ? len : max_bytes;
+  int64 n = bytes;
 
   while (n) {
-    ink64 l = block_read_avail();
+    int64 l = block_read_avail();
     if (n < l)
       l = n;
     ::memcpy(b, start(), l);
@@ -206,22 +206,22 @@ IOBufferReader::read(void *ab, ink64 len
   return bytes;
 }
 
-ink64
-IOBufferReader::memchr(char c, ink64 len, ink64 offset)
+int64
+IOBufferReader::memchr(char c, int64 len, int64 offset)
 {
   IOBufferBlock *b = block;
   offset += start_offset;
-  ink64 o = offset;
+  int64 o = offset;
 
   while (b && len) {
-    ink64 max_bytes = b->read_avail();
+    int64 max_bytes = b->read_avail();
     max_bytes -= offset;
     if (max_bytes <= 0) {
       offset = -max_bytes;
       b = b->next;
       continue;
     }
-    ink64 bytes;
+    int64 bytes;
     if (len<0 || len>= max_bytes)
       bytes = max_bytes;
     else
@@ -229,7 +229,7 @@ IOBufferReader::memchr(char c, ink64 len
     char *s = b->start() + offset;
     char *p = (char *) ink_memchr(s, c, bytes);
     if (p)
-      return (ink64) (o - start_offset + p - s);
+      return (int64) (o - start_offset + p - s);
     o += bytes;
     len -= bytes;
     b = b->next;
@@ -240,21 +240,21 @@ IOBufferReader::memchr(char c, ink64 len
 }
 
 char *
-IOBufferReader::memcpy(void *ap, ink64 len, ink64 offset)
+IOBufferReader::memcpy(void *ap, int64 len, int64 offset)
 {
   char *p = (char*)ap;
   IOBufferBlock *b = block;
   offset += start_offset;
 
   while (b && len) {
-    ink64 max_bytes = b->read_avail();
+    int64 max_bytes = b->read_avail();
     max_bytes -= offset;
     if (max_bytes <= 0) {
       offset = -max_bytes;
       b = b->next;
       continue;
     }
-    ink64 bytes;
+    int64 bytes;
     if (len<0 || len>= max_bytes)
       bytes = max_bytes;
     else

Modified: trafficserver/traffic/trunk/iocore/eventsystem/I_IOBuffer.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/I_IOBuffer.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/I_IOBuffer.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/I_IOBuffer.h Wed May 19 21:06:35 2010
@@ -50,9 +50,9 @@ class VIO;
 // Removing this optimization since this is breaking WMT over HTTP
 //#define WRITE_AND_TRANSFER
 
-inkcoreapi extern ink64 max_iobuffer_size;
-extern ink64 default_small_iobuffer_size;
-extern ink64 default_large_iobuffer_size; // matched to size of OS buffers
+inkcoreapi extern int64 max_iobuffer_size;
+extern int64 default_small_iobuffer_size;
+extern int64 default_large_iobuffer_size; // matched to size of OS buffers
 
 #if !defined(PURIFY)
 // Define this macro to enable buffer usage tracking.
@@ -112,7 +112,7 @@ enum AllocType
 #define BUFFER_SIZE_NOT_ALLOCATED    DEFAULT_BUFFER_SIZES
 #define BUFFER_SIZE_INDEX_IS_XMALLOCED(_size_index) (_size_index < 0)
 #define BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(_size_index) \
-  (((inku64)_size_index) < DEFAULT_BUFFER_SIZES)
+  (((uint64)_size_index) < DEFAULT_BUFFER_SIZES)
 #define BUFFER_SIZE_INDEX_IS_CONSTANT(_size_index) \
   (_size_index >= DEFAULT_BUFFER_SIZES)
 
@@ -179,7 +179,7 @@ public:
     @return number of bytes allocated for the '_data' member.
 
   */
-  ink64 block_size();
+  int64 block_size();
 
   /**
     Frees the memory managed by this IOBufferData.  Deallocates the
@@ -199,7 +199,7 @@ public:
     @param size_index
     @param type of allocation to use; see remarks section.
   */
-  void alloc(ink64 size_index, AllocType type = DEFAULT_ALLOC);
+  void alloc(int64 size_index, AllocType type = DEFAULT_ALLOC);
 
   /**
     Provides access to the allocated memory. Returns the address of the
@@ -233,7 +233,7 @@ public:
   */
   virtual void free();
 
-  ink64 _size_index;
+  int64 _size_index;
 
   /**
     Type of allocation used for the managed memory. Stores the type of
@@ -340,9 +340,9 @@ public:
     @return bytes occupied by the inuse area.
 
   */
-  ink64 size()
+  int64 size()
   {
-    return (ink64) (_end - _start);
+    return (int64) (_end - _start);
   }
 
   /**
@@ -352,9 +352,9 @@ public:
     @return bytes available for reading from the inuse area.
 
   */
-  ink64 read_avail()
+  int64 read_avail()
   {
-    return (ink64) (_end - _start);
+    return (int64) (_end - _start);
   }
 
   /**
@@ -363,9 +363,9 @@ public:
 
     @return space available for writing in this IOBufferBlock.
   */
-  ink64 write_avail()
+  int64 write_avail()
   {
-    return (ink64) (_buf_end - _end);
+    return (int64) (_buf_end - _end);
   }
 
   /**
@@ -378,7 +378,7 @@ public:
       IOBufferBlock.
 
   */
-  ink64 block_size()
+  int64 block_size()
   {
     return data->block_size();
   }
@@ -392,7 +392,7 @@ public:
       the inuse area.
 
   */
-  void consume(ink64 len);
+  void consume(int64 len);
 
   /**
     Increase the inuse area of the block. Adds 'len' bytes to the inuse
@@ -404,7 +404,7 @@ public:
       or equal to the value of write_avail().
 
   */
-  void fill(ink64 len);
+  void fill(int64 len);
 
   /**
     Reset the inuse area. The start and end of the inuse area are reset
@@ -443,7 +443,7 @@ public:
     section in MIOBuffer.
 
   */
-  void alloc(ink64 i = default_large_iobuffer_size);
+  void alloc(int64 i = default_large_iobuffer_size);
 
   /**
     Clear the IOBufferData this IOBufferBlock handles. Clears this
@@ -465,13 +465,13 @@ public:
       and to mark its start.
 
   */
-  void set(IOBufferData * d, ink64 len = 0, ink64 offset = 0);
-  void set_internal(void *b, ink64 len, ink64 asize_index);
-  void realloc_set_internal(void *b, ink64 buf_size, ink64 asize_index);
-  void realloc(void *b, ink64 buf_size);
-  void realloc(ink64 i);
-  void realloc_xmalloc(void *b, ink64 buf_size);
-  void realloc_xmalloc(ink64 buf_size);
+  void set(IOBufferData * d, int64 len = 0, int64 offset = 0);
+  void set_internal(void *b, int64 len, int64 asize_index);
+  void realloc_set_internal(void *b, int64 buf_size, int64 asize_index);
+  void realloc(void *b, int64 buf_size);
+  void realloc(int64 i);
+  void realloc_xmalloc(void *b, int64 buf_size);
+  void realloc_xmalloc(int64 buf_size);
 
   /**
     Frees the IOBufferBlock object and its underlying memory.
@@ -564,7 +564,7 @@ public:
     @return bytes of data available across all the buffers.
 
   */
-  ink64 read_avail();
+  int64 read_avail();
 
   /**
     Number of IOBufferBlocks with data in the block list. Returns the
@@ -585,7 +585,7 @@ public:
       buffer.
 
   */
-  ink64 block_read_avail();
+  int64 block_read_avail();
 
   void skip_empty_blocks();
 
@@ -616,7 +616,7 @@ public:
       to read_avail().
 
   */
-  void consume(ink64 n);
+  void consume(int64 n);
 
   /**
     Create another reader with access to the same data as this
@@ -690,7 +690,7 @@ public:
 
     @param c character to look for.
     @param len number of characters to check. If len exceeds the number
-      of bytes available on the buffer or INK64_MAX is passed in, the
+      of bytes available on the buffer or INT64_MAX is passed in, the
       number of bytes available to the reader is used. It is independent
       of the offset value.
     @param offset number of the bytes to skip over before beginning
@@ -699,7 +699,7 @@ public:
       ocurrence.
 
   */
-  inkcoreapi ink64 memchr(char c, ink64 len = INK64_MAX, ink64 offset = 0);
+  inkcoreapi int64 memchr(char c, int64 len = INT64_MAX, int64 offset = 0);
 
   /**
     Copies and consumes data. Copies len bytes of data from the buffer
@@ -715,7 +715,7 @@ public:
     @return number of bytes copied and consumed.
 
   */
-  inkcoreapi ink64 read(void *buf, ink64 len);
+  inkcoreapi int64 read(void *buf, int64 len);
 
   /**
     Copy data but do not consume it. Copies 'len' bytes of data from
@@ -726,7 +726,7 @@ public:
     @param buf in which to place the data. The pointer is modified after
       the call and points one position after the end of the data copied.
     @param len bytes to copy. If len exceeds the bytes available to the
-      reader or INK64_MAX is passed in, the number of bytes available is
+      reader or INT64_MAX is passed in, the number of bytes available is
       used instead. No data is consumed from the reader in this operation.
     @param offset bytes to skip from the current position. The parameter
       is modified after the call.
@@ -734,7 +734,7 @@ public:
       parameter buf is set to this value also.
 
   */
-  inkcoreapi char *memcpy(void *buf, ink64 len = INK64_MAX, ink64 offset = 0);
+  inkcoreapi char *memcpy(void *buf, int64 len = INT64_MAX, int64 offset = 0);
 
   /**
     Subscript operator. Returns a reference to the character at the
@@ -747,7 +747,7 @@ public:
     @return reference to the character in that position.
 
   */
-  char &operator[] (ink64 i);
+  char &operator[] (int64 i);
 
   MIOBuffer *writer()
   {
@@ -774,10 +774,10 @@ public:
     of the available data.
 
   */
-  ink64 start_offset;
-  ink64 size_limit;
+  int64 start_offset;
+  int64 size_limit;
 
-  IOBufferReader():accessor(NULL), mbuf(NULL), start_offset(0), size_limit(INK64_MAX) {
+  IOBufferReader():accessor(NULL), mbuf(NULL), start_offset(0), size_limit(INT64_MAX) {
   }
 };
 
@@ -809,7 +809,7 @@ public:
     @param len number of bytes to add to the inuse area of the block.
 
   */
-  void fill(ink64 len);
+  void fill(int64 len);
 
   /**
     Adds a block to the end of the block list. The block added to list
@@ -825,7 +825,7 @@ public:
     buffer block sizes.
 
   */
-  void append_block(ink64 asize_index);
+  void append_block(int64 asize_index);
 
   /**
     Adds new block to the end of block list using the block size for
@@ -841,7 +841,7 @@ public:
     by the buffer once all readers on the buffer have consumed it.
 
   */
-  void append_xmalloced(void *b, ink64 len);
+  void append_xmalloced(void *b, int64 len);
 
   /**
     Adds by reference len bytes of data pointed to by b to the end of the
@@ -851,7 +851,7 @@ public:
     have consumed it.
 
   */
-  void append_fast_allocated(void *b, ink64 len, ink64 fast_size_index);
+  void append_fast_allocated(void *b, int64 len, int64 fast_size_index);
 
   /**
     Adds the nbytes worth of data pointed by rbuf to the buffer. The
@@ -860,7 +860,7 @@ public:
     control. Returns the number of bytes added.
 
   */
-  inkcoreapi ink64 write(const void *rbuf, ink64 nbytes);
+  inkcoreapi int64 write(const void *rbuf, int64 nbytes);
 
 #ifdef WRITE_AND_TRANSFER
   /**
@@ -869,7 +869,7 @@ public:
     this space becomes available to the copy.
 
   */
-  inkcoreapi ink64 write_and_transfer_left_over_space(IOBufferReader * r, ink64 len = INK64_MAX, ink64 offset = 0);
+  inkcoreapi int64 write_and_transfer_left_over_space(IOBufferReader * r, int64 len = INT64_MAX, int64 offset = 0);
 #endif
 
   /**
@@ -897,9 +897,9 @@ public:
     rather than sharing blocks to prevent a build of blocks on the buffer.
 
   */
-  inkcoreapi ink64 write(IOBufferReader * r, ink64 len = INK64_MAX, ink64 offset = 0);
+  inkcoreapi int64 write(IOBufferReader * r, int64 len = INT64_MAX, int64 offset = 0);
 
-  ink64 remove_append(IOBufferReader *);
+  int64 remove_append(IOBufferReader *);
 
   /**
     Returns a pointer to the first writable block on the block chain.
@@ -943,7 +943,7 @@ public:
     by first_write_block()).
 
   */
-  ink64 block_write_avail();
+  int64 block_write_avail();
 
   /**
     Returns the amount of space of available for writing on all writable
@@ -951,7 +951,7 @@ public:
     block chain.
 
   */
-  ink64 current_write_avail();
+  int64 current_write_avail();
 
   /**
     Adds blocks for writing if the watermark criteria are met. Returns
@@ -959,19 +959,19 @@ public:
     on the block chain after a block due to the watermark criteria.
 
   */
-  ink64 write_avail();
+  int64 write_avail();
 
   /**
     Returns the default data block size for this buffer.
 
   */
-  ink64 block_size();
+  int64 block_size();
 
   /**
     Returns the default data block size for this buffer.
 
   */
-  ink64 total_size()
+  int64 total_size()
   {
     return block_size();
   }
@@ -1006,7 +1006,7 @@ public:
   {
     return current_write_avail() <= water_mark;
   }
-  void set_size_index(ink64 size);
+  void set_size_index(int64 size);
 
   /**
     Allocates a new IOBuffer reader and sets it's its 'accessor' field
@@ -1050,12 +1050,12 @@ public:
   */
   void dealloc_all_readers();
 
-  void set(void *b, ink64 len);
-  void set_xmalloced(void *b, ink64 len);
-  void alloc(ink64 i = default_large_iobuffer_size);
-  void alloc_xmalloc(ink64 buf_size);
+  void set(void *b, int64 len);
+  void set_xmalloced(void *b, int64 len);
+  void alloc(int64 i = default_large_iobuffer_size);
+  void alloc_xmalloc(int64 buf_size);
   void append_block_internal(IOBufferBlock * b);
-  ink64 puts(char *buf, ink64 len);
+  int64 puts(char *buf, int64 len);
 
   // internal interface
 
@@ -1063,7 +1063,7 @@ public:
   {
     return !_writer;
   }
-  ink64 max_read_avail();
+  int64 max_read_avail();
   int max_block_count();
   void check_add_block();
 
@@ -1100,24 +1100,24 @@ public:
     water_mark = 0;
   }
 
-  void realloc(ink64 i)
+  void realloc(int64 i)
   {
     _writer->realloc(i);
   }
-  void realloc(void *b, ink64 buf_size)
+  void realloc(void *b, int64 buf_size)
   {
     _writer->realloc(b, buf_size);
   }
-  void realloc_xmalloc(void *b, ink64 buf_size)
+  void realloc_xmalloc(void *b, int64 buf_size)
   {
     _writer->realloc_xmalloc(b, buf_size);
   }
-  void realloc_xmalloc(ink64 buf_size)
+  void realloc_xmalloc(int64 buf_size)
   {
     _writer->realloc_xmalloc(buf_size);
   }
 
-  ink64 size_index;
+  int64 size_index;
 
   /**
     Determines when to stop writing or reading. The watermark is the
@@ -1127,7 +1127,7 @@ public:
     no matter how small.
 
   */
-  ink64 water_mark;
+  int64 water_mark;
 
   Ptr<IOBufferBlock> _writer;
   IOBufferReader readers[MAX_MIOBUFFER_READERS];
@@ -1136,8 +1136,8 @@ public:
   const char *_location;
 #endif
 
-  MIOBuffer(void *b, ink64 bufsize, ink64 aWater_mark);
-  MIOBuffer(ink64 default_size_index);
+  MIOBuffer(void *b, int64 bufsize, int64 aWater_mark);
+  MIOBuffer(int64 default_size_index);
   MIOBuffer();
   ~MIOBuffer();
 };
@@ -1157,11 +1157,11 @@ struct MIOBufferAccessor
     return mbuf;
   }
 
-  ink64 block_size()
+  int64 block_size()
   {
     return mbuf->block_size();
   }
-  ink64 total_size()
+  int64 total_size()
   {
     return block_size();
   }
@@ -1203,7 +1203,7 @@ TS_INLINE MIOBuffer * new_MIOBuffer_inte
 #ifdef TRACK_BUFFER_USER
                                           const char *loc,
 #endif
-                                          ink64 size_index = default_large_iobuffer_size);
+                                          int64 size_index = default_large_iobuffer_size);
 
 #ifdef TRACK_BUFFER_USER
 class MIOBuffer_tracker
@@ -1214,7 +1214,7 @@ public:
     MIOBuffer_tracker(const char *_loc):loc(_loc)
   {
   }
-  MIOBuffer *operator() (ink64 size_index = default_large_iobuffer_size) {
+  MIOBuffer *operator() (int64 size_index = default_large_iobuffer_size) {
     return new_MIOBuffer_internal(loc, size_index);
   }
 
@@ -1225,7 +1225,7 @@ TS_INLINE MIOBuffer * new_empty_MIOBuffe
 #ifdef TRACK_BUFFER_USER
                                                      const char *loc,
 #endif
-                                                     ink64 size_index = default_large_iobuffer_size);
+                                                     int64 size_index = default_large_iobuffer_size);
 
 #ifdef TRACK_BUFFER_USER
 class Empty_MIOBuffer_tracker
@@ -1236,7 +1236,7 @@ public:
     Empty_MIOBuffer_tracker(const char *_loc):loc(_loc)
   {
   }
-  MIOBuffer *operator() (ink64 size_index = default_large_iobuffer_size) {
+  MIOBuffer *operator() (int64 size_index = default_large_iobuffer_size) {
     return new_empty_MIOBuffer_internal(loc, size_index);
   }
 };
@@ -1262,7 +1262,7 @@ TS_INLINE IOBufferBlock * new_IOBufferBl
 #ifdef TRACK_BUFFER_USER
                                                        const char *loc,
 #endif
-                                                       IOBufferData * d, ink64 len = 0, ink64 offset = 0);
+                                                       IOBufferData * d, int64 len = 0, int64 offset = 0);
 
 #ifdef TRACK_BUFFER_USER
 class IOBufferBlock_tracker
@@ -1277,7 +1277,7 @@ public:
   {
     return new_IOBufferBlock_internal(loc);
   }
-  IOBufferBlock *operator() (IOBufferData * d, ink64 len = 0, ink64 offset = 0) {
+  IOBufferBlock *operator() (IOBufferData * d, int64 len = 0, int64 offset = 0) {
     return new_IOBufferBlock_internal(loc, d, len, offset);
   }
 
@@ -1296,20 +1296,20 @@ TS_INLINE IOBufferData *new_IOBufferData
 #ifdef TRACK_BUFFER_USER
                                                     const char *location,
 #endif
-                                                    ink64 size_index = default_large_iobuffer_size,
+                                                    int64 size_index = default_large_iobuffer_size,
                                                     AllocType type = DEFAULT_ALLOC);
 
 TS_INLINE IOBufferData *new_xmalloc_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                                                             const char *location,
 #endif
-                                                            void *b, ink64 size);
+                                                            void *b, int64 size);
 
 TS_INLINE IOBufferData *new_constant_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                                                              const char *loc,
 #endif
-                                                             void *b, ink64 size);
+                                                             void *b, int64 size);
 
 
 #ifdef TRACK_BUFFER_USER
@@ -1321,7 +1321,7 @@ public:
     IOBufferData_tracker(const char *_loc):loc(_loc)
   {
   }
-  IOBufferData *operator() (ink64 size_index = default_large_iobuffer_size, AllocType type = DEFAULT_ALLOC) {
+  IOBufferData *operator() (int64 size_index = default_large_iobuffer_size, AllocType type = DEFAULT_ALLOC) {
     return new_IOBufferData_internal(loc, size_index, type);
   }
 
@@ -1342,8 +1342,8 @@ new_constant_IOBufferData_internal(RES_P
 #define  new_constant_IOBufferData new_constant_IOBufferData_internal
 #endif
 
-TS_INLINE ink64 iobuffer_size_to_index(ink64 size, ink64 max = max_iobuffer_size);
-TS_INLINE ink64 index_to_buffer_size(ink64 idx);
+TS_INLINE int64 iobuffer_size_to_index(int64 size, int64 max = max_iobuffer_size);
+TS_INLINE int64 index_to_buffer_size(int64 idx);
 /**
   Clone a IOBufferBlock chain. Used to snarf a IOBufferBlock chain
   w/o copy.
@@ -1354,7 +1354,7 @@ TS_INLINE ink64 index_to_buffer_size(ink
   @return ptr to head of new IOBufferBlock chain.
 
 */
-TS_INLINE IOBufferBlock *iobufferblock_clone(IOBufferBlock * b, ink64 offset, ink64 len);
+TS_INLINE IOBufferBlock *iobufferblock_clone(IOBufferBlock * b, int64 offset, int64 len);
 /**
   Skip over specified bytes in chain. Used for dropping references.
 
@@ -1366,5 +1366,5 @@ TS_INLINE IOBufferBlock *iobufferblock_c
   @return ptr to head of new IOBufferBlock chain.
 
 */
-TS_INLINE IOBufferBlock *iobufferblock_skip(IOBufferBlock * b, ink64 *poffset, ink64 *plen, ink64 write);
+TS_INLINE IOBufferBlock *iobufferblock_skip(IOBufferBlock * b, int64 *poffset, int64 *plen, int64 write);
 #endif

Modified: trafficserver/traffic/trunk/iocore/eventsystem/I_PriorityEventQueue.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/I_PriorityEventQueue.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/I_PriorityEventQueue.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/I_PriorityEventQueue.h Wed May 19 21:06:35 2010
@@ -40,7 +40,7 @@ struct PriorityEventQueue
 
   Que(Event, link) after[N_PQ_LIST];
   ink_hrtime last_check_time;
-  inku32 last_check_buckets;
+  uint32 last_check_buckets;
 
   void enqueue(Event * e, ink_hrtime now)
   {

Modified: trafficserver/traffic/trunk/iocore/eventsystem/I_SocketManager.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/I_SocketManager.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/I_SocketManager.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/I_SocketManager.h Wed May 19 21:06:35 2010
@@ -55,24 +55,24 @@ struct SocketManager
   int open(const char *path, int oflag = O_RDWR | O_NDELAY | O_CREAT, mode_t mode = DEFAULT_OPEN_MODE);
 
   // result is the number of bytes or -errno
-  ink64 read(int fd, void *buf, int len, void *pOLP = NULL);
-  ink64 vector_io(int fd, struct iovec *vector, size_t count, int read_request, void *pOLP = 0);
-  ink64 readv(int fd, struct iovec *vector, size_t count);
-  ink64 read_vector(int fd, struct iovec *vector, size_t count, void *pOLP = 0);
-  ink64 pread(int fd, void *buf, int len, off_t offset, char *tag = NULL);
+  int64 read(int fd, void *buf, int len, void *pOLP = NULL);
+  int64 vector_io(int fd, struct iovec *vector, size_t count, int read_request, void *pOLP = 0);
+  int64 readv(int fd, struct iovec *vector, size_t count);
+  int64 read_vector(int fd, struct iovec *vector, size_t count, void *pOLP = 0);
+  int64 pread(int fd, void *buf, int len, off_t offset, char *tag = NULL);
 
   int recv(int s, void *buf, int len, int flags);
   int recvfrom(int fd, void *buf, int size, int flags, struct sockaddr *addr, socklen_t *addrlen);
 
-  ink64 write(int fd, void *buf, int len, void *pOLP = NULL);
-  ink64 writev(int fd, struct iovec *vector, size_t count);
-  ink64 write_vector(int fd, struct iovec *vector, size_t count, void *pOLP = 0);
-  ink64 pwrite(int fd, void *buf, int len, off_t offset, char *tag = NULL);
+  int64 write(int fd, void *buf, int len, void *pOLP = NULL);
+  int64 writev(int fd, struct iovec *vector, size_t count);
+  int64 write_vector(int fd, struct iovec *vector, size_t count, void *pOLP = 0);
+  int64 pwrite(int fd, void *buf, int len, off_t offset, char *tag = NULL);
 
   int send(int fd, void *buf, int len, int flags);
   int sendto(int fd, void *buf, int len, int flags, struct sockaddr *to, int tolen);
   int sendmsg(int fd, struct msghdr *m, int flags, void *pOLP = 0);
-  ink64 lseek(int fd, off_t offset, int whence);
+  int64 lseek(int fd, off_t offset, int whence);
   int fstat(int fd, struct stat *);
   int unlink(char *buf);
   int fsync(int fildes);

Modified: trafficserver/traffic/trunk/iocore/eventsystem/I_VConnection.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/I_VConnection.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/I_VConnection.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/I_VConnection.h Wed May 19 21:06:35 2010
@@ -185,12 +185,12 @@ public:
 
     @param c Continuation to be called back with events.
     @param nbytes Number of bytes to read. If unknown, nbytes must
-      be set to INK64_MAX.
+      be set to INT64_MAX.
     @param buf buffer to read into.
     @return VIO representing the scheduled IO operation.
 
   */
-  virtual VIO *do_io_read(Continuation *c = NULL, ink64 nbytes = INK64_MAX, MIOBuffer *buf = 0) = 0;
+  virtual VIO *do_io_read(Continuation *c = NULL, int64 nbytes = INT64_MAX, MIOBuffer *buf = 0) = 0;
 
   /**
     Write data to the VConnection.
@@ -234,14 +234,14 @@ public:
 
     @param c Continuation to be called back with events.
     @param nbytes Number of bytes to write. If unknown, nbytes must
-      be set to INK64_MAX.
+      be set to INT64_MAX.
     @param buf Reader whose data is to be read from.
     @param owner
     @return VIO representing the scheduled IO operation.
 
   */
   virtual VIO *do_io_write(Continuation *c = NULL,
-                           ink64 nbytes = INK64_MAX, IOBufferReader *buf = 0, bool owner = false) = 0;
+                           int64 nbytes = INT64_MAX, IOBufferReader *buf = 0, bool owner = false) = 0;
 
   /**
     Indicate that the VConnection is no longer needed.
@@ -306,11 +306,11 @@ public:
     VConnection(ProxyMutex *aMutex);
 
 #if defined (_IOCORE_WIN32_WINNT)
-  virtual void set_nbytes(VIO *vio, ink64 nbytes);
+  virtual void set_nbytes(VIO *vio, int64 nbytes);
 #endif
 
   /** @deprecated */
-  VIO *do_io(int op, Continuation *c = NULL, ink64 nbytes = INK64_MAX, MIOBuffer *buf = 0, int data = 0);
+  VIO *do_io(int op, Continuation *c = NULL, int64 nbytes = INT64_MAX, MIOBuffer *buf = 0, int data = 0);
 
   // Private
   // Set continuation on a given vio. The public interface
@@ -380,7 +380,7 @@ public:
 
 struct DummyVConnection:VConnection
 {
-  virtual VIO *do_io_write(Continuation *c = NULL, ink64 nbytes = INK64_MAX, IOBufferReader *buf = 0, bool owner = false) {
+  virtual VIO *do_io_write(Continuation *c = NULL, int64 nbytes = INT64_MAX, IOBufferReader *buf = 0, bool owner = false) {
     (void) c;
     (void) nbytes;
     (void) buf;
@@ -388,7 +388,7 @@ struct DummyVConnection:VConnection
     ink_debug_assert(!"VConnection::do_io_write -- " "cannot use default implementation");
     return NULL;
   }
-  virtual VIO *do_io_read(Continuation *c = NULL, ink64 nbytes = INK64_MAX, MIOBuffer *buf = 0) {
+  virtual VIO *do_io_read(Continuation *c = NULL, int64 nbytes = INT64_MAX, MIOBuffer *buf = 0) {
     (void) c;
     (void) nbytes;
     (void) buf;
@@ -405,7 +405,7 @@ struct DummyVConnection:VConnection
     ink_debug_assert(!"VConnection::do_io_shutdown -- " "cannot use default implementation");
   }
 #ifdef _IOCORE_WIN32_WINNT
-  virtual void set_nbytes(VIO *vio, ink64 nbytes)
+  virtual void set_nbytes(VIO *vio, int64 nbytes)
   {
     (void) vio;
     (void) nbytes;

Modified: trafficserver/traffic/trunk/iocore/eventsystem/I_VIO.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/I_VIO.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/I_VIO.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/I_VIO.h Wed May 19 21:06:35 2010
@@ -98,7 +98,7 @@ public:
     @return The number of bytes to be processed by the operation.
 
   */
-  ink64 ntodo();
+  int64 ntodo();
 
   /////////////////////
   // buffer settings //
@@ -169,7 +169,7 @@ public:
     The total number of bytes this operation must complete.
 
   */
-  ink64 nbytes;
+  int64 nbytes;
 
   /**
     Number of bytes already completed.
@@ -179,7 +179,7 @@ public:
     the lock.
 
   */
-  ink64 ndone;
+  int64 ndone;
 
   /**
     Type of operation.

Modified: trafficserver/traffic/trunk/iocore/eventsystem/PQ-List.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/PQ-List.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/PQ-List.cc (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/PQ-List.cc Wed May 19 21:06:35 2010
@@ -33,8 +33,8 @@ void
 PriorityEventQueue::check_ready(ink_hrtime now, EThread * t)
 {
   int i, j, k = 0;
-  inku32 check_buckets = (inku32) (now / PQ_BUCKET_TIME(0));
-  inku32 todo_buckets = check_buckets ^ last_check_buckets;
+  uint32 check_buckets = (uint32) (now / PQ_BUCKET_TIME(0));
+  uint32 todo_buckets = check_buckets ^ last_check_buckets;
   last_check_time = now;
   last_check_buckets = check_buckets;
   todo_buckets &= ((1 << (N_PQ_LIST - 1)) - 1);

Modified: trafficserver/traffic/trunk/iocore/eventsystem/P_IOBuffer.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/P_IOBuffer.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/P_IOBuffer.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/P_IOBuffer.h Wed May 19 21:06:35 2010
@@ -33,8 +33,8 @@
 // +1 for each power of 2
 //
 //////////////////////////////////////////////////////////////
-TS_INLINE ink64
-buffer_size_to_index(ink64 size, ink64 max = max_iobuffer_size)
+TS_INLINE int64
+buffer_size_to_index(int64 size, int64 max = max_iobuffer_size)
 {
   int r = max;
   while (r && BUFFER_SIZE_FOR_INDEX(r - 1) >= size)
@@ -42,16 +42,16 @@ buffer_size_to_index(ink64 size, ink64 m
   return r;
 }
 
-TS_INLINE ink64
-iobuffer_size_to_index(ink64 size, ink64 max)
+TS_INLINE int64
+iobuffer_size_to_index(int64 size, int64 max)
 {
   if (size > BUFFER_SIZE_FOR_INDEX(max))
     return BUFFER_SIZE_INDEX_FOR_XMALLOC_SIZE(size);
   return buffer_size_to_index(size, max);
 }
 
-TS_INLINE ink64
-index_to_buffer_size(ink64 idx)
+TS_INLINE int64
+index_to_buffer_size(int64 idx)
 {
   if (BUFFER_SIZE_INDEX_IS_FAST_ALLOCATED(idx))
     return BUFFER_SIZE_FOR_INDEX(idx);
@@ -65,7 +65,7 @@ index_to_buffer_size(ink64 idx)
 }
 
 TS_INLINE IOBufferBlock *
-iobufferblock_clone(IOBufferBlock * b, ink64 offset, ink64 len)
+iobufferblock_clone(IOBufferBlock * b, int64 offset, int64 len)
 {
 
   IOBufferBlock *start_buf = NULL;
@@ -74,14 +74,14 @@ iobufferblock_clone(IOBufferBlock * b, i
   while (b && len >= 0) {
     char *start = b->_start;
     char *end = b->_end;
-    ink64 max_bytes = end - start;
+    int64 max_bytes = end - start;
     max_bytes -= offset;
     if (max_bytes <= 0) {
       offset = -max_bytes;
       b = b->next;
       continue;
     }
-    ink64 bytes = len;
+    int64 bytes = len;
     if (bytes >= max_bytes)
       bytes = max_bytes;
     IOBufferBlock *new_buf = b->clone();
@@ -102,12 +102,12 @@ iobufferblock_clone(IOBufferBlock * b, i
 }
 
 TS_INLINE IOBufferBlock *
-iobufferblock_skip(IOBufferBlock * b, ink64 *poffset, ink64 *plen, ink64 write)
+iobufferblock_skip(IOBufferBlock * b, int64 *poffset, int64 *plen, int64 write)
 {
-  ink64 offset = *poffset;
-  ink64 len = write;
+  int64 offset = *poffset;
+  int64 len = write;
   while (b && len >= 0) {
-    ink64 max_bytes = b->read_avail();
+    int64 max_bytes = b->read_avail();
     max_bytes -= offset;
     if (max_bytes <= 0) {
       offset = -max_bytes;
@@ -133,7 +133,7 @@ struct Resource;
 extern Resource *res_lookup(const char *path);
 
 TS_INLINE void
-iobuffer_mem_inc(const char *_loc, ink64 _size_index)
+iobuffer_mem_inc(const char *_loc, int64 _size_index)
 {
   if (!res_track_memory)
     return;
@@ -145,14 +145,14 @@ iobuffer_mem_inc(const char *_loc, ink64
     _loc = "memory/IOBuffer/UNKNOWN-LOCATION";
   Resource *res = res_lookup(_loc);
   ink_debug_assert(strcmp(_loc, res->path) == 0);
-  ink64 r = ink_atomic_increment64(&res->value,
+  int64 r = ink_atomic_increment64(&res->value,
                                    index_to_buffer_size(_size_index));
   NOWARN_UNUSED(r);
   ink_debug_assert(r >= 0);
 }
 
 TS_INLINE void
-iobuffer_mem_dec(const char *_loc, ink64 _size_index)
+iobuffer_mem_dec(const char *_loc, int64 _size_index)
 {
   if (!res_track_memory)
     return;
@@ -163,7 +163,7 @@ iobuffer_mem_dec(const char *_loc, ink64
     _loc = "memory/IOBuffer/UNKNOWN-LOCATION";
   Resource *res = res_lookup(_loc);
   ink_debug_assert(strcmp(_loc, res->path) == 0);
-  ink64 r = ink_atomic_increment64(&res->value,
+  int64 r = ink_atomic_increment64(&res->value,
                                    -index_to_buffer_size(_size_index));
   NOWARN_UNUSED(r);
   ink_debug_assert(r >= index_to_buffer_size(_size_index));
@@ -181,7 +181,7 @@ iobuffer_mem_dec(const char *_loc, ink64
 //         inline functions definitions
 //
 //////////////////////////////////////////////////////////////////
-TS_INLINE ink64
+TS_INLINE int64
 IOBufferData::block_size()
 {
   return index_to_buffer_size(_size_index);
@@ -192,7 +192,7 @@ new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                            const char *location,
 #endif
-                           void *b, ink64 size, ink64 asize_index)
+                           void *b, int64 size, int64 asize_index)
 {
   (void) size;
   IOBufferData *d = ioDataAllocator.alloc();
@@ -211,7 +211,7 @@ new_constant_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                                     const char *loc,
 #endif
-                                    void *b, ink64 size)
+                                    void *b, int64 size)
 {
   return new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
@@ -225,7 +225,7 @@ new_xmalloc_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                                    const char *location,
 #endif
-                                   void *b, ink64 size)
+                                   void *b, int64 size)
 {
   return new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
@@ -239,7 +239,7 @@ new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                            const char *location,
 #endif
-                           void *b, ink64 size)
+                           void *b, int64 size)
 {
   return new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
@@ -253,7 +253,7 @@ new_IOBufferData_internal(
 #ifdef TRACK_BUFFER_USER
                            const char *loc,
 #endif
-                           ink64 size_index, AllocType type)
+                           int64 size_index, AllocType type)
 {
   IOBufferData *d = ioDataAllocator.alloc();
 #ifdef TRACK_BUFFER_USER
@@ -268,7 +268,7 @@ new_IOBufferData_internal(
 // so it is DUPLICATED in IOBuffer.cc
 // ****** IF YOU CHANGE THIS FUNCTION change that one as well.
 TS_INLINE void
-IOBufferData::alloc(ink64 size_index, AllocType type)
+IOBufferData::alloc(int64 size_index, AllocType type)
 {
   if (_data)
     dealloc();
@@ -357,7 +357,7 @@ new_IOBufferBlock_internal(
 #ifdef TRACK_BUFFER_USER
                             const char *location,
 #endif
-                            IOBufferData * d, ink64 len, ink64 offset)
+                            IOBufferData * d, int64 len, int64 offset)
 {
   IOBufferBlock *b = ioBlockAllocator.alloc();
 #ifdef TRACK_BUFFER_USER
@@ -381,14 +381,14 @@ _location(0)
 }
 
 TS_INLINE void
-IOBufferBlock::consume(ink64 len)
+IOBufferBlock::consume(int64 len)
 {
   _start += len;
   ink_assert(_start <= _end);
 }
 
 TS_INLINE void
-IOBufferBlock::fill(ink64 len)
+IOBufferBlock::fill(int64 len)
 {
   _end += len;
   ink_assert(_end <= _buf_end);
@@ -402,7 +402,7 @@ IOBufferBlock::reset()
 }
 
 TS_INLINE void
-IOBufferBlock::alloc(ink64 i)
+IOBufferBlock::alloc(int64 i)
 {
   ink_debug_assert(BUFFER_SIZE_ALLOCATED(i));
 #ifdef TRACK_BUFFER_USER
@@ -465,7 +465,7 @@ IOBufferBlock::free()
 }
 
 TS_INLINE void
-IOBufferBlock::set_internal(void *b, ink64 len, ink64 asize_index)
+IOBufferBlock::set_internal(void *b, int64 len, int64 asize_index)
 {
 #ifdef TRACK_BUFFER_USER
   data = new_IOBufferData_internal(_location, BUFFER_SIZE_NOT_ALLOCATED);
@@ -482,7 +482,7 @@ IOBufferBlock::set_internal(void *b, ink
 }
 
 TS_INLINE void
-IOBufferBlock::set(IOBufferData * d, ink64 len, ink64 offset)
+IOBufferBlock::set(IOBufferData * d, int64 len, int64 offset)
 {
   data = d;
   _start = buf() + offset;
@@ -491,9 +491,9 @@ IOBufferBlock::set(IOBufferData * d, ink
 }
 
 TS_INLINE void
-IOBufferBlock::realloc_set_internal(void *b, ink64 buf_size, ink64 asize_index)
+IOBufferBlock::realloc_set_internal(void *b, int64 buf_size, int64 asize_index)
 {
-  ink64 data_size = size();
+  int64 data_size = size();
   memcpy(b, _start, size());
   dealloc();
   set_internal(b, buf_size, asize_index);
@@ -501,29 +501,29 @@ IOBufferBlock::realloc_set_internal(void
 }
 
 TS_INLINE void
-IOBufferBlock::realloc(void *b, ink64 buf_size)
+IOBufferBlock::realloc(void *b, int64 buf_size)
 {
   realloc_set_internal(b, buf_size, BUFFER_SIZE_NOT_ALLOCATED);
 }
 
 TS_INLINE void
-IOBufferBlock::realloc_xmalloc(void *b, ink64 buf_size)
+IOBufferBlock::realloc_xmalloc(void *b, int64 buf_size)
 {
   realloc_set_internal(b, buf_size, -buf_size);
 }
 
 TS_INLINE void
-IOBufferBlock::realloc_xmalloc(ink64 buf_size)
+IOBufferBlock::realloc_xmalloc(int64 buf_size)
 {
   realloc_set_internal(xmalloc(buf_size), buf_size, -buf_size);
 }
 
 TS_INLINE void
-IOBufferBlock::realloc(ink64 i)
+IOBufferBlock::realloc(int64 i)
 {
   if (i == data->_size_index)
     return;
-  if (i >= (ink64) sizeof(ioBufAllocator))
+  if (i >= (int64) sizeof(ioBufAllocator))
     return;
 
   ink_release_assert(i > data->_size_index && i != BUFFER_SIZE_NOT_ALLOCATED);
@@ -588,13 +588,13 @@ IOBufferReader::end()
   return block->end();
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 IOBufferReader::block_read_avail()
 {
   if (block == 0)
     return (0);
   skip_empty_blocks();
-  return (ink64) (block->end() - (block->start() + start_offset));
+  return (int64) (block->end() - (block->start() + start_offset));
 }
 
 TS_INLINE int
@@ -609,32 +609,32 @@ IOBufferReader::block_count()
   return count;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 IOBufferReader::read_avail()
 {
-  ink64 t = 0;
+  int64 t = 0;
   IOBufferBlock *b = block;
   while (b) {
     t += b->read_avail();
     b = b->next;
   }
   t -= start_offset;
-  if (size_limit != INK64_MAX && t > size_limit)
+  if (size_limit != INT64_MAX && t > size_limit)
     t = size_limit;
   return t;
 }
 
 TS_INLINE void
-IOBufferReader::consume(ink64 n)
+IOBufferReader::consume(int64 n)
 {
   start_offset += n;
-  if (size_limit != INK64_MAX)
+  if (size_limit != INT64_MAX)
     size_limit -= n;
   ink_assert(size_limit >= 0);
   if (block == 0)
     return;
-  ink64 r = block->read_avail();
-  ink64 s = start_offset;
+  int64 r = block->read_avail();
+  int64 s = start_offset;
   while (r <= s && block->next && block->next->read_avail()) {
     s -= r;
     start_offset = s;
@@ -645,7 +645,7 @@ IOBufferReader::consume(ink64 n)
 }
 
 TS_INLINE char &
-IOBufferReader::operator[] (ink64 i)
+IOBufferReader::operator[] (int64 i)
 {
   static char
     _error = '\0';
@@ -654,7 +654,7 @@ IOBufferReader::operator[] (ink64 i)
     b = block;
   i += start_offset;
   while (b) {
-    ink64 bytes = b->read_avail();
+    int64 bytes = b->read_avail();
     if (bytes > i)
       return b->start()[i];
     i -= bytes;
@@ -675,7 +675,7 @@ IOBufferReader::clear()
   block = NULL;
   mbuf = NULL;
   start_offset = 0;
-  size_limit = INK64_MAX;
+  size_limit = INT64_MAX;
 }
 
 TS_INLINE void
@@ -683,7 +683,7 @@ IOBufferReader::reset()
 {
   block = mbuf->_writer;
   start_offset = 0;
-  size_limit = INK64_MAX;
+  size_limit = INT64_MAX;
 }
 
 ////////////////////////////////////////////////////////////////
@@ -707,7 +707,7 @@ inkcoreapi extern ClassAllocator<MIOBuff
 //
 ////////////////////////////////////////////////////////////////
 TS_INLINE
-MIOBuffer::MIOBuffer(void *b, ink64 bufsize, ink64 aWater_mark)
+MIOBuffer::MIOBuffer(void *b, int64 bufsize, int64 aWater_mark)
 {
   set(b, bufsize);
   water_mark = aWater_mark;
@@ -719,7 +719,7 @@ MIOBuffer::MIOBuffer(void *b, ink64 bufs
 }
 
 TS_INLINE
-MIOBuffer::MIOBuffer(ink64 default_size_index)
+MIOBuffer::MIOBuffer(int64 default_size_index)
 {
   clear();
   size_index = default_size_index;
@@ -751,7 +751,7 @@ TS_INLINE MIOBuffer * new_MIOBuffer_inte
 #ifdef TRACK_BUFFER_USER
                                                const char *location,
 #endif
-                                               ink64 size_index)
+                                               int64 size_index)
 {
   MIOBuffer *b = ioAllocator.alloc();
 #ifdef TRACK_BUFFER_USER
@@ -773,7 +773,7 @@ TS_INLINE MIOBuffer * new_empty_MIOBuffe
 #ifdef TRACK_BUFFER_USER
                                                      const char *location,
 #endif
-                                                     ink64 size_index)
+                                                     int64 size_index)
 {
   MIOBuffer *b = ioAllocator.alloc();
   b->size_index = size_index;
@@ -827,7 +827,7 @@ MIOBuffer::alloc_reader()
   return e;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 MIOBuffer::block_size()
 {
   return index_to_buffer_size(size_index);
@@ -854,7 +854,7 @@ MIOBuffer::clone_reader(IOBufferReader *
   return e;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 MIOBuffer::block_write_avail()
 {
   IOBufferBlock *b = first_write_block();
@@ -915,7 +915,7 @@ MIOBuffer::append_block(IOBufferBlock * 
 //
 ////////////////////////////////////////////////////////////////
 TS_INLINE void
-MIOBuffer::append_block(ink64 asize_index)
+MIOBuffer::append_block(int64 asize_index)
 {
   ink_debug_assert(BUFFER_SIZE_ALLOCATED(asize_index));
 #ifdef TRACK_BUFFER_USER
@@ -957,10 +957,10 @@ MIOBuffer::get_current_block()
 //  or below the watermark space available.
 //
 //////////////////////////////////////////////////////////////////
-TS_INLINE ink64
+TS_INLINE int64
 MIOBuffer::current_write_avail()
 {
-  ink64 t = 0;
+  int64 t = 0;
   IOBufferBlock *b = _writer;
   while (b) {
     t += b->write_avail();
@@ -978,7 +978,7 @@ MIOBuffer::current_write_avail()
 //  the current block then a new block is appended.
 //
 //////////////////////////////////////////////////////////////////
-TS_INLINE ink64
+TS_INLINE int64
 MIOBuffer::write_avail()
 {
   check_add_block();
@@ -986,9 +986,9 @@ MIOBuffer::write_avail()
 }
 
 TS_INLINE void
-MIOBuffer::fill(ink64 len)
+MIOBuffer::fill(int64 len)
 {
-  ink64 f = _writer->write_avail();
+  int64 f = _writer->write_avail();
   while (f < len) {
     _writer->fill(f);
     len -= f;
@@ -1014,14 +1014,14 @@ MIOBuffer::max_block_count()
   return maxb;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 MIOBuffer::max_read_avail()
 {
-  ink64 s = 0;
+  int64 s = 0;
   int found = 0;
   for (int i = 0; i < MAX_MIOBUFFER_READERS; i++) {
     if (readers[i].allocated()) {
-      ink64 ss = readers[i].read_avail();
+      int64 ss = readers[i].read_avail();
       if (ss > s) {
         s = ss;
       }
@@ -1034,7 +1034,7 @@ MIOBuffer::max_read_avail()
 }
 
 TS_INLINE void
-MIOBuffer::set(void *b, ink64 len)
+MIOBuffer::set(void *b, int64 len)
 {
 #ifdef TRACK_BUFFER_USER
   _writer = new_IOBufferBlock_internal(_location);
@@ -1046,7 +1046,7 @@ MIOBuffer::set(void *b, ink64 len)
 }
 
 TS_INLINE void
-MIOBuffer::set_xmalloced(void *b, ink64 len)
+MIOBuffer::set_xmalloced(void *b, int64 len)
 {
 #ifdef TRACK_BUFFER_USER
   _writer = new_IOBufferBlock_internal(_location);
@@ -1058,7 +1058,7 @@ MIOBuffer::set_xmalloced(void *b, ink64 
 }
 
 TS_INLINE void
-MIOBuffer::append_xmalloced(void *b, ink64 len)
+MIOBuffer::append_xmalloced(void *b, int64 len)
 {
 #ifdef TRACK_BUFFER_USER
   IOBufferBlock *x = new_IOBufferBlock_internal(_location);
@@ -1070,7 +1070,7 @@ MIOBuffer::append_xmalloced(void *b, ink
 }
 
 TS_INLINE void
-MIOBuffer::append_fast_allocated(void *b, ink64 len, ink64 fast_size_index)
+MIOBuffer::append_fast_allocated(void *b, int64 len, int64 fast_size_index)
 {
 #ifdef TRACK_BUFFER_USER
   IOBufferBlock *x = new_IOBufferBlock_internal(_location);
@@ -1082,7 +1082,7 @@ MIOBuffer::append_fast_allocated(void *b
 }
 
 TS_INLINE void
-MIOBuffer::alloc(ink64 i)
+MIOBuffer::alloc(int64 i)
 {
 #ifdef TRACK_BUFFER_USER
   _writer = new_IOBufferBlock_internal(_location);
@@ -1095,7 +1095,7 @@ MIOBuffer::alloc(ink64 i)
 }
 
 TS_INLINE void
-MIOBuffer::alloc_xmalloc(ink64 buf_size)
+MIOBuffer::alloc_xmalloc(int64 buf_size)
 {
   char *b = (char *) xmalloc(buf_size);
   set_xmalloced(b, buf_size);
@@ -1133,7 +1133,7 @@ MIOBuffer::dealloc_all_readers()
 }
 
 TS_INLINE void
-MIOBuffer::set_size_index(ink64 size)
+MIOBuffer::set_size_index(int64 size)
 {
   size_index = iobuffer_size_to_index(size);
 }

Modified: trafficserver/traffic/trunk/iocore/eventsystem/P_UnixSocketManager.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/P_UnixSocketManager.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/P_UnixSocketManager.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/P_UnixSocketManager.h Wed May 19 21:06:35 2010
@@ -86,10 +86,10 @@ SocketManager::open(const char *path, in
   return s;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::read(int fd, void *buf, int size, void *pOLP)
 {
-  ink64 r;
+  int64 r;
   do {
     r =::read(fd, buf, size);
     if (likely(r >= 0))
@@ -99,10 +99,10 @@ SocketManager::read(int fd, void *buf, i
   return r;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::pread(int fd, void *buf, int size, off_t offset, char *tag)
 {
-  ink64 r;
+  int64 r;
   do {
     r =::pread(fd, buf, size, offset);
     if (r < 0)
@@ -111,10 +111,10 @@ SocketManager::pread(int fd, void *buf, 
   return r;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::readv(int fd, struct iovec *vector, size_t count)
 {
-  ink64 r;
+  int64 r;
   do {
     // coverity[tainted_data_argument]
     if (likely((r =::readv(fd, vector, count)) >= 0))
@@ -124,16 +124,16 @@ SocketManager::readv(int fd, struct iove
   return r;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::vector_io(int fd, struct iovec *vector, size_t count, int read_request, void *pOLP)
 {
   const int max_iovecs_per_request = 16;
   int n;
-  ink64 r = 0;
+  int64 r = 0;
   int n_vec;
-  ink64 bytes_xfered = 0;
+  int64 bytes_xfered = 0;
   int current_count;
-  ink64 current_request_bytes;
+  int64 current_request_bytes;
 
   for (n_vec = 0; n_vec < (int) count; n_vec += max_iovecs_per_request) {
     current_count = min(max_iovecs_per_request, ((int) (count - n_vec)));
@@ -165,7 +165,7 @@ SocketManager::vector_io(int fd, struct 
   return bytes_xfered;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::read_vector(int fd, struct iovec *vector, size_t count, void *pOLP)
 {
   return vector_io(fd, vector, count, 1, pOLP);
@@ -195,10 +195,10 @@ SocketManager::recvfrom(int fd, void *bu
   return r;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::write(int fd, void *buf, int size, void *pOLP)
 {
-  ink64 r;
+  int64 r;
   do {
     if (likely((r =::write(fd, buf, size)) >= 0))
       break;
@@ -207,10 +207,10 @@ SocketManager::write(int fd, void *buf, 
   return r;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::pwrite(int fd, void *buf, int size, off_t offset, char *tag)
 {
-  ink64 r;
+  int64 r;
   do {
     if (unlikely((r =::pwrite(fd, buf, size, offset)) < 0))
       r = -errno;
@@ -218,10 +218,10 @@ SocketManager::pwrite(int fd, void *buf,
   return r;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::writev(int fd, struct iovec *vector, size_t count)
 {
-  ink64 r;
+  int64 r;
   do {
     if (likely((r =::writev(fd, vector, count)) >= 0))
       break;
@@ -230,7 +230,7 @@ SocketManager::writev(int fd, struct iov
   return r;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::write_vector(int fd, struct iovec *vector, size_t count, void *pOLP)
 {
   return vector_io(fd, vector, count, 0, pOLP);
@@ -270,10 +270,10 @@ SocketManager::sendmsg(int fd, struct ms
   return r;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 SocketManager::lseek(int fd, off_t offset, int whence)
 {
-  ink64 r;
+  int64 r;
   do {
     if ((r =::lseek(fd, offset, whence)) < 0)
       r = -errno;

Modified: trafficserver/traffic/trunk/iocore/eventsystem/P_VConnection.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/P_VConnection.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/P_VConnection.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/P_VConnection.h Wed May 19 21:06:35 2010
@@ -84,7 +84,7 @@ VConnection()
 //////////////////////////////////////////////////////////////////////////////
 
 static TS_INLINE VIO *
-vc_do_io_write(VConnection * vc, Continuation * cont, ink64 nbytes, MIOBuffer * buf, ink64 offset)
+vc_do_io_write(VConnection * vc, Continuation * cont, int64 nbytes, MIOBuffer * buf, int64 offset)
 {
   IOBufferReader *reader = buf->alloc_reader();
 
@@ -95,7 +95,7 @@ vc_do_io_write(VConnection * vc, Continu
 }
 
 TS_INLINE VIO *
-VConnection::do_io(int op, Continuation * c, ink64 nbytes, MIOBuffer * cb, int data)
+VConnection::do_io(int op, Continuation * c, int64 nbytes, MIOBuffer * cb, int data)
 {
   switch (op) {
   case VIO::READ:

Modified: trafficserver/traffic/trunk/iocore/eventsystem/P_VIO.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/eventsystem/P_VIO.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/eventsystem/P_VIO.h (original)
+++ trafficserver/traffic/trunk/iocore/eventsystem/P_VIO.h Wed May 19 21:06:35 2010
@@ -84,7 +84,7 @@ VIO::get_reader()
 {
   return (buffer.reader());
 }
-TS_INLINE ink64
+TS_INLINE int64
 VIO::ntodo()
 {
   return nbytes - ndone;

Modified: trafficserver/traffic/trunk/iocore/hostdb/HostDB.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/hostdb/HostDB.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/hostdb/HostDB.cc (original)
+++ trafficserver/traffic/trunk/iocore/hostdb/HostDB.cc Wed May 19 21:06:35 2010
@@ -400,10 +400,10 @@ HostDBProcessor::start(int)
   IOCORE_EstablishStaticConfigInt32(hostdb_re_dns_on_reload, "proxy.config.hostdb.re_dns_on_reload");
   IOCORE_EstablishStaticConfigInt32(hostdb_migrate_on_demand, "proxy.config.hostdb.migrate_on_demand");
   /* mgmt stuff
-     ink64 ii = pmgmt->record_data->readConfigInteger(
+     int64 ii = pmgmt->record_data->readConfigInteger(
      "proxy.config.hostdb.strict_round_robin", &found);
      if (found) {
-     hostdb_strict_round_robin = (ink32) ii;
+     hostdb_strict_round_robin = (int32) ii;
      pmgmt->record_data->registerConfigUpdateFunc(
      "proxy.config.hostdb.strict_round_robin",config_int_cb,
      (void*)&hostdb_strict_round_robin);
@@ -562,7 +562,7 @@ probe(ProxyMutex * mutex,
 {
   ink_debug_assert(this_ethread() == hostDB.lock_for_bucket((int) (fold_md5(md5) % hostDB.buckets))->thread_holding);
   if (hostdb_enable) {
-    inku64 folded_md5 = fold_md5(md5);
+    uint64 folded_md5 = fold_md5(md5);
     HostDBInfo *r = hostDB.lookup_block(folded_md5, hostDB.levels);
     Debug("hostdb", "probe %s %llX %d [ignore_timeout = %d]", hostname, folded_md5, !!r, ignore_timeout);
     if (r && md5[1] == r->md5_high) {
@@ -630,7 +630,7 @@ HostDBInfo *
 HostDBContinuation::insert(unsigned int attl)
 {
   ink_debug_assert(this_ethread() == hostDB.lock_for_bucket((int) (fold_md5(md5) % hostDB.buckets))->thread_holding);
-  inku64 folded_md5 = fold_md5(md5);
+  uint64 folded_md5 = fold_md5(md5);
   // remove the old one to prevent buildup
   HostDBInfo *old_r = hostDB.lookup_block(folded_md5, 3);
   if (old_r)
@@ -706,11 +706,11 @@ HostDBProcessor::getby(Continuation * co
     // so that it does not intersect the string space
     //
     // suvasv: Changed from this
-    //    inku64 dummy = ip << 16;
-    //  to inku64 dummy = ip*64*1024 for bug INKqa10029.
+    //    uint64 dummy = ip << 16;
+    //  to uint64 dummy = ip*64*1024 for bug INKqa10029.
     //  Problem was that ip << 16 would not work for architectures with
     //  a different byte order. This takes cares of all byte orders.
-    inku64 dummy = ((inku64) ip) * 64 * 1024;
+    uint64 dummy = ((uint64) ip) * 64 * 1024;
     md5.encodeBuffer((char *) &dummy, 8);
   }
 
@@ -1004,11 +1004,11 @@ HostDBProcessor::setby(char *hostname, i
     //
 
     // suvasv: Changed from this
-    //    inku64 dummy = ip << 16;
-    //  to inku64 dummy = ip*64*1024 for bug INKqa10029.
+    //    uint64 dummy = ip << 16;
+    //  to uint64 dummy = ip*64*1024 for bug INKqa10029.
     //  Problem was that ip << 16 would not work for architectures with
     //  a different byte order. This takes cares of all byte orders.
-    inku64 dummy = ((inku64) ip) * 64 * 1024;
+    uint64 dummy = ((uint64) ip) * 64 * 1024;
     md5.encodeBuffer((char *) &dummy, 8);
   }
 
@@ -2039,9 +2039,9 @@ bool HostDBInfo::match(INK_MD5 & md5, in
   if (md5[1] != md5_high)
     return false;
 
-  inku64
+  uint64
     folded_md5 = fold_md5(md5);
-  inku64
+  uint64
     ttag = folded_md5 / buckets;
 
   if (!ttag)

Modified: trafficserver/traffic/trunk/iocore/hostdb/I_HostDBProcessor.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/hostdb/I_HostDBProcessor.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/hostdb/I_HostDBProcessor.h (original)
+++ trafficserver/traffic/trunk/iocore/hostdb/I_HostDBProcessor.h Wed May 19 21:06:35 2010
@@ -242,7 +242,7 @@ struct HostDBInfo
     unsigned int ip;
     int hostname_offset;
     // int srv_host_offset;
-    inku64 dummy_pad;
+    uint64 dummy_pad;
   } data;
 
   unsigned int srv_weight:16;
@@ -266,7 +266,7 @@ struct HostDBInfo
   unsigned int md5_low_low:24;
   unsigned int md5_low;
 
-  inku64 md5_high;
+  uint64 md5_high;
 
   bool failed() {
     return !ip();
@@ -303,9 +303,9 @@ struct HostDBInfo
     srv_count = 0;
   }
 
-  void set_full(inku64 folded_md5, int buckets)
+  void set_full(uint64 folded_md5, int buckets)
   {
-    inku64 ttag = folded_md5 / buckets;
+    uint64 ttag = folded_md5 / buckets;
     if (!ttag)
       ttag = 1;
     md5_low_low = (unsigned int) ttag;
@@ -325,8 +325,8 @@ struct HostDBInfo
     reverse_dns = 0;
   }
 
-  inku64 tag() {
-    inku64 f = md5_low;
+  uint64 tag() {
+    uint64 f = md5_low;
     return (f << 24) + md5_low_low;
   }
 
@@ -386,7 +386,7 @@ struct HostDBRoundRobin
   HostDBInfo *find_ip(unsigned int ip);
   HostDBInfo *select_best(unsigned int client_ip, HostDBInfo * r = NULL);
 
-  HostDBInfo *select_best_http(unsigned int client_ip, time_t now, ink32 fail_window);
+  HostDBInfo *select_best_http(unsigned int client_ip, time_t now, int32 fail_window);
 
   HostDBInfo *increment_round_robin()
   {

Modified: trafficserver/traffic/trunk/iocore/hostdb/MultiCache.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/hostdb/MultiCache.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/hostdb/MultiCache.cc (original)
+++ trafficserver/traffic/trunk/iocore/hostdb/MultiCache.cc Wed May 19 21:06:35 2010
@@ -82,7 +82,7 @@ buckets(0), totalelements(0), totalsize(
 }
 
 static inline int
-bytes_to_blocks(ink64 b)
+bytes_to_blocks(int64 b)
 {
   return (int) ((b + (STORE_BLOCK_SIZE - 1)) / STORE_BLOCK_SIZE);
 }
@@ -90,11 +90,11 @@ bytes_to_blocks(ink64 b)
 inline int
 MultiCacheBase::blocks_in_level(int level)
 {
-  ink64 sumbytes = 0;
+  int64 sumbytes = 0;
   int prevblocks = 0;
   int b = 0;
   for (int i = 0; i <= level; i++) {
-    sumbytes += buckets * ((ink64) bucketsize[i]);
+    sumbytes += buckets * ((int64) bucketsize[i]);
     int sumblocks = bytes_to_blocks(sumbytes);
     b = sumblocks - prevblocks;
     prevblocks = sumblocks;
@@ -113,7 +113,7 @@ MultiCacheBase::initialize(Store * astor
                            int level0_elements_per_bucket,
                            int level1_elements_per_bucket, int level2_elements_per_bucket)
 {
-  ink64 size = 0;
+  int64 size = 0;
   ink_assert(alevels < 4);
   levels = alevels;
   elementsize = get_elementsize();
@@ -136,7 +136,7 @@ MultiCacheBase::initialize(Store * astor
     elements[2] = level2_elements_per_bucket;
     totalelements += buckets * level2_elements_per_bucket;
     bucketsize[2] = elementsize * level2_elements_per_bucket;
-    size += (ink64) bucketsize[2] * (ink64) buckets;
+    size += (int64) bucketsize[2] * (int64) buckets;
 
     if (!(level2_elements_per_bucket / level1_elements_per_bucket)) {
       Warning("Size change too large, unable to reconfigure");
@@ -159,7 +159,7 @@ MultiCacheBase::initialize(Store * astor
     elements[1] = level1_elements_per_bucket;
     totalelements += buckets * level1_elements_per_bucket;
     bucketsize[1] = elementsize * level1_elements_per_bucket;
-    size += (ink64) bucketsize[1] * (ink64) buckets;
+    size += (int64) bucketsize[1] * (int64) buckets;
     if (!(level1_elements_per_bucket / level0_elements_per_bucket)) {
       Warning("Size change too large, unable to reconfigure");
       return -2;
@@ -179,7 +179,7 @@ MultiCacheBase::initialize(Store * astor
   elements[0] = level0_elements_per_bucket;
   totalelements += buckets * level0_elements_per_bucket;
   bucketsize[0] = elementsize * level0_elements_per_bucket;
-  size += (ink64) bucketsize[0] * (ink64) buckets;
+  size += (int64) bucketsize[0] * (int64) buckets;
 
   buckets_per_partitionF8 = (buckets << 8) / MULTI_CACHE_PARTITIONS;
   ink_release_assert(buckets_per_partitionF8);
@@ -191,7 +191,7 @@ MultiCacheBase::initialize(Store * astor
 
   blocks += 1;                  // header
 
-  totalsize = (ink64) blocks *(ink64) STORE_BLOCK_SIZE;
+  totalsize = (int64) blocks *(int64) STORE_BLOCK_SIZE;
 
   //
   //  Spread alloc from the store (using storage that can be mmapped)
@@ -297,8 +297,8 @@ MultiCacheBase::unmap_data()
 struct zorch_info
 {
   int fd;
-  ink64 size;
-  ink64 fsize;
+  int64 size;
+  int64 fsize;
   int val;
 };
 
@@ -310,7 +310,7 @@ static void *
 _zorch_file(void *arg)
 {
   zorch_info *info = (zorch_info *) arg;
-  ink64 amount;
+  int64 amount;
   char *vals;
 
   if (info) {
@@ -321,7 +321,7 @@ _zorch_file(void *arg)
         if (amount > (info->size - info->fsize))
           amount = info->size - info->fsize;
 
-        if (ink_pwrite(info->fd, vals, amount, info->fsize) < 0)
+        if (pwrite(info->fd, vals, amount, info->fsize) < 0)
           break;
         info->fsize += amount;
       }
@@ -334,12 +334,12 @@ _zorch_file(void *arg)
 }
 
 static int
-zorch_file(char *path, int fd, ink64 size, int val)
+zorch_file(char *path, int fd, int64 size, int val)
 {
   struct stat stat;
-  ink64 fsize;
+  int64 fsize;
 
-  if (ink_fstat(fd, &stat) < 0) {
+  if (fstat(fd, &stat) < 0) {
     return -1;
   }
 
@@ -349,7 +349,7 @@ zorch_file(char *path, int fd, ink64 siz
     Note("file '%s' size changed from %0.2fMB to %0.2fMB", path, fsize / (1024.0 * 1024.0), size / (1024.0 * 1024.0));
   }
 
-  if (ink_ftruncate(fd, size) < 0) {
+  if (ftruncate(fd, size) < 0) {
     return -1;
   }
 
@@ -400,9 +400,9 @@ MultiCacheBase::mmap_data(bool private_f
         fds[n_fds] = 0;
       }
       if (!d->file_pathname) {
-        if (zorch_file(path, fds[n_fds], (ink64) d->blocks * (ink64) STORE_BLOCK_SIZE, 0)) {
+        if (zorch_file(path, fds[n_fds], (int64) d->blocks * (int64) STORE_BLOCK_SIZE, 0)) {
           Warning("unable to set file size '%s' to %lld: %d, %s",
-                  (ink64) d->blocks * STORE_BLOCK_SIZE, path, errno, strerror(errno));
+                  (int64) d->blocks * STORE_BLOCK_SIZE, path, errno, strerror(errno));
           goto Lvalloc;
         }
       }

Modified: trafficserver/traffic/trunk/iocore/hostdb/P_HostDBProcessor.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/hostdb/P_HostDBProcessor.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/hostdb/P_HostDBProcessor.h (original)
+++ trafficserver/traffic/trunk/iocore/hostdb/P_HostDBProcessor.h Wed May 19 21:06:35 2010
@@ -197,7 +197,7 @@ HostDBRoundRobin::select_best(unsigned i
 }
 
 inline HostDBInfo *
-HostDBRoundRobin::select_best_http(unsigned int client_ip, time_t now, ink32 fail_window)
+HostDBRoundRobin::select_best_http(unsigned int client_ip, time_t now, int32 fail_window)
 {
   bool bad = (n <= 0 || n > HOST_DB_MAX_ROUND_ROBIN_INFO || good <= 0 || good > HOST_DB_MAX_ROUND_ROBIN_INFO);
   if (bad) {
@@ -234,7 +234,7 @@ HostDBRoundRobin::select_best_http(unsig
         //  as to how far in the future we should tolerate bogus last
         //  failure times.  This sets the upper bound that we would ever
         //  consider a server down to 2*down_server_timeout
-        if (now + fail_window < (ink32) (info[i].app.http_data.last_failure)) {
+        if (now + fail_window < (int32) (info[i].app.http_data.last_failure)) {
 #ifdef DEBUG
           // because this region is mmaped, I cann't get anything
           //   useful from the structure in core files,  therefore

Modified: trafficserver/traffic/trunk/iocore/hostdb/P_MultiCache.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/hostdb/P_MultiCache.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/hostdb/P_MultiCache.h (original)
+++ trafficserver/traffic/trunk/iocore/hostdb/P_MultiCache.h Wed May 19 21:06:35 2010
@@ -61,7 +61,7 @@
 
 #define MULTI_CACHE_HEAP_HIGH_WATER  0.8
 
-#define MULTI_CACHE_HEAP_INITIAL     sizeof(inku32)
+#define MULTI_CACHE_HEAP_INITIAL     sizeof(uint32)
 #define MULTI_CACHE_HEAP_ALIGNMENT   8
 
 // unused.. possible optimization
@@ -83,13 +83,13 @@ struct Continuation;
 
 struct MultiCacheBlock
 {
-  inku64 tag();
+  uint64 tag();
   bool is_deleted();
   void set_deleted();
   bool is_empty();
   void set_empty();
   void reset();
-  void set_full(inku64 folded_md5, int buckets);
+  void set_full(uint64 folded_md5, int buckets);
   int heap_size()
   {
     return 0;
@@ -329,9 +329,9 @@ struct MultiCacheBase:MultiCacheHeader
   {
     return locks[partition_of_bucket(bucket)];
   }
-  inku64 make_tag(inku64 folded_md5)
+  uint64 make_tag(uint64 folded_md5)
   {
-    inku64 ttag = folded_md5 / (inku64) buckets;
+    uint64 ttag = folded_md5 / (uint64) buckets;
 #if !defined (_WIN32)
     if (!ttag)
       return 1LL;
@@ -341,14 +341,14 @@ struct MultiCacheBase:MultiCacheHeader
 #endif
     // beeping gcc 2.7.2 is broken
     if (tag_bits > 32) {
-      inku64 mask = 0x100000000LL << (tag_bits - 32);
+      uint64 mask = 0x100000000LL << (tag_bits - 32);
       mask = mask - 1;
       return ttag & mask;
     } else {
 #if !defined (_WIN32)
-      inku64 mask = 1LL;
+      uint64 mask = 1LL;
 #else
-      inku64 mask = 1i 64;
+      uint64 mask = 1i 64;
 #endif
       mask <<= tag_bits;
       mask = mask - 1;
@@ -456,16 +456,16 @@ template<class C> struct MultiCache:Mult
   // template operations
   //
   int level_of_block(C * b);
-  bool match(inku64 folded_md5, C * block);
-  C *cache_bucket(inku64 folded_md5, int level);
-  C *insert_block(inku64 folded_md5, C * new_block, int level);
+  bool match(uint64 folded_md5, C * block);
+  C *cache_bucket(uint64 folded_md5, int level);
+  C *insert_block(uint64 folded_md5, C * new_block, int level);
   void flush(C * b, int bucket, int level);
   void delete_block(C * block);
-  C *lookup_block(inku64 folded_md5, int level);
+  C *lookup_block(uint64 folded_md5, int level);
   void copy_heap(int paritition, MultiCacheHeapGC *);
 };
 
-inline inku64
+inline uint64
 fold_md5(INK_MD5 & md5)
 {
   return (md5.fold());
@@ -481,7 +481,7 @@ template<class C> inline int MultiCache<
   return 0;
 }
 
-template<class C> inline C * MultiCache<C>::cache_bucket(inku64 folded_md5, int level)
+template<class C> inline C * MultiCache<C>::cache_bucket(uint64 folded_md5, int level)
 {
   int bucket = (int) (folded_md5 % buckets);
   char *offset = data + level_offset[level] + bucketsize[level] * bucket;
@@ -491,7 +491,7 @@ template<class C> inline C * MultiCache<
 //
 // Insert an entry
 //
-template<class C> inline C * MultiCache<C>::insert_block(inku64 folded_md5, C * new_block, int level)
+template<class C> inline C * MultiCache<C>::insert_block(uint64 folded_md5, C * new_block, int level)
 {
   C *b = cache_bucket(folded_md5, level);
   C *block = NULL, *empty = NULL;
@@ -500,7 +500,7 @@ template<class C> inline C * MultiCache<
 
   // Find the entry
   //
-  inku64 tag = make_tag(folded_md5);
+  uint64 tag = make_tag(folded_md5);
   int n_empty = 0;
 
   for (block = b; block < b + elements[level]; block++) {
@@ -557,7 +557,7 @@ Lfound:
 }
 
 #define REBUILD_FOLDED_MD5(_cl) \
-((_cl->tag() * (inku64)buckets + (inku64)bucket))
+((_cl->tag() * (uint64)buckets + (uint64)bucket))
 
 //
 // This function ejects some number of entries.
@@ -583,7 +583,7 @@ template<class C> inline void MultiCache
 //
 // Match a cache line and a folded md5 key
 //
-template<class C> inline bool MultiCache<C>::match(inku64 folded_md5, C * block)
+template<class C> inline bool MultiCache<C>::match(uint64 folded_md5, C * block)
 {
   return block->tag() == make_tag(folded_md5);
 }
@@ -609,10 +609,10 @@ template<class C> inline void MultiCache
 //
 // Lookup an entry up to some level in the cache
 //
-template<class C> inline C * MultiCache<C>::lookup_block(inku64 folded_md5, int level)
+template<class C> inline C * MultiCache<C>::lookup_block(uint64 folded_md5, int level)
 {
   C *b = cache_bucket(folded_md5, 0);
-  inku64 tag = make_tag(folded_md5);
+  uint64 tag = make_tag(folded_md5);
   int i = 0;
   // Level 0
   for (i = 0; i < elements[0]; i++)

Modified: trafficserver/traffic/trunk/iocore/hostdb/include/Machine.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/hostdb/include/Machine.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/hostdb/include/Machine.h (original)
+++ trafficserver/traffic/trunk/iocore/hostdb/include/Machine.h Wed May 19 21:06:35 2010
@@ -78,8 +78,8 @@ struct Machine:Server
    ~Machine();
 
   // Cluster message protocol version
-  inku16 msg_proto_major;
-  inku16 msg_proto_minor;
+  uint16 msg_proto_major;
+  uint16 msg_proto_minor;
 
   // Private data for ClusterProcessor
   //

Modified: trafficserver/traffic/trunk/iocore/net/Connection.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/Connection.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/Connection.cc (original)
+++ trafficserver/traffic/trunk/iocore/net/Connection.cc Wed May 19 21:06:35 2010
@@ -120,7 +120,7 @@ Connection::close()
 int
 Connection::fast_connect(const unsigned int ip, const int port, NetVCOptions * opt, const int sock)
 {
-  inku32 *z;
+  uint32 *z;
   int res = 0;
 
   if (sock < 0) {
@@ -135,7 +135,7 @@ Connection::fast_connect(const unsigned 
   sa.sin_family = AF_INET;
   sa.sin_port = htons(port);
   sa.sin_addr.s_addr = ip;
-  z = (inku32 *) & sa.sin_zero;
+  z = (uint32 *) & sa.sin_zero;
   z[0] = 0;
   z[1] = 0;
 

Modified: trafficserver/traffic/trunk/iocore/net/I_NetVConnection.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/I_NetVConnection.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/I_NetVConnection.h (original)
+++ trafficserver/traffic/trunk/iocore/net/I_NetVConnection.h Wed May 19 21:06:35 2010
@@ -91,7 +91,7 @@ enum NetDataType
 struct NetVCOptions {
   int local_port;
 
-  inku32 spoof_ip;
+  uint32 spoof_ip;
   int spoof_port;
 
   unsigned char socks_support;
@@ -149,7 +149,7 @@ public:
     @return vio
 
   */
-  virtual VIO * do_io_read(Continuation * c, ink64 nbytes, MIOBuffer * buf) = 0;
+  virtual VIO * do_io_read(Continuation * c, int64 nbytes, MIOBuffer * buf) = 0;
 
   /**
     Initiates write. Thread-safe, may be called when not handling
@@ -185,7 +185,7 @@ public:
     @return vio pointer
 
   */
-  virtual VIO *do_io_write(Continuation * c, ink64 nbytes, IOBufferReader * buf, bool owner = false) = 0;
+  virtual VIO *do_io_write(Continuation * c, int64 nbytes, IOBufferReader * buf, bool owner = false) = 0;
 
   /**
     Closes the vconnection. A state machine MUST call do_io_close()

Modified: trafficserver/traffic/trunk/iocore/net/I_UDPConnection.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/I_UDPConnection.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/I_UDPConnection.h (original)
+++ trafficserver/traffic/trunk/iocore/net/I_UDPConnection.h Wed May 19 21:06:35 2010
@@ -93,8 +93,8 @@ public:
   int getPortNum(void);
 
   int GetSendGenerationNumber();        //const
-  void SetLastSentPktTSSeqNum(ink64 sentSeqNum);
-  ink64 cancel();
+  void SetLastSentPktTSSeqNum(int64 sentSeqNum);
+  int64 cancel();
   void setContinuation(Continuation * c);
 
   /**

Modified: trafficserver/traffic/trunk/iocore/net/I_UDPPacket.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/I_UDPPacket.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/I_UDPPacket.h (original)
+++ trafficserver/traffic/trunk/iocore/net/I_UDPPacket.h Wed May 19 21:06:35 2010
@@ -56,7 +56,7 @@ public:
   void setArrivalTime(ink_hrtime t);
   IOBufferBlock *getIOBlockChain();
   void setReliabilityPkt();
-  void setPktTSSeq(ink64 seqno);
+  void setPktTSSeq(int64 seqno);
   int getPktLength();
   /**
      Add IOBufferBlock (chain) to end of packet.

Modified: trafficserver/traffic/trunk/iocore/net/NetVCTest.cc
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/NetVCTest.cc?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/NetVCTest.cc (original)
+++ trafficserver/traffic/trunk/iocore/net/NetVCTest.cc Wed May 19 21:06:35 2010
@@ -199,7 +199,7 @@ NetVCTest::start_test()
 
 
 int
-NetVCTest::fill_buffer(MIOBuffer * buf, inku8 * seed, int bytes)
+NetVCTest::fill_buffer(MIOBuffer * buf, uint8 * seed, int bytes)
 {
 
   char *space = (char *) xmalloc(bytes);
@@ -220,10 +220,10 @@ NetVCTest::fill_buffer(MIOBuffer * buf, 
 }
 
 int
-NetVCTest::consume_and_check_bytes(IOBufferReader * r, inku8 * seed)
+NetVCTest::consume_and_check_bytes(IOBufferReader * r, uint8 * seed)
 {
 
-  inku8 *tmp, *end;
+  uint8 *tmp, *end;
   int b_consumed = 0;
 
   if (actual_bytes_read >= bytes_to_read) {
@@ -233,7 +233,7 @@ NetVCTest::consume_and_check_bytes(IOBuf
   while (r->read_avail() > 0) {
     int b_avail = r->block_read_avail();
 
-    tmp = (inku8 *) r->start();
+    tmp = (uint8 *) r->start();
     end = tmp + b_avail;
     b_consumed = 0;
 

Modified: trafficserver/traffic/trunk/iocore/net/P_NetVCTest.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/P_NetVCTest.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/P_NetVCTest.h (original)
+++ trafficserver/traffic/trunk/iocore/net/P_NetVCTest.h Wed May 19 21:06:35 2010
@@ -101,8 +101,8 @@ public:
                  NetVConnection * nvc, RegressionTest * robj,
                  NVC_test_def * my_def, const char *module_name_arg, const char *debug_tag_arg);
   void start_test();
-  int fill_buffer(MIOBuffer * buf, inku8 * seed, int bytes);
-  int consume_and_check_bytes(IOBufferReader * r, inku8 * seed);
+  int fill_buffer(MIOBuffer * buf, uint8 * seed, int bytes);
+  int consume_and_check_bytes(IOBufferReader * r, uint8 * seed);
 
   void write_finished();
   void read_finished();
@@ -131,8 +131,8 @@ public:
   bool write_done;
   bool read_done;
 
-  inku8 read_seed;
-  inku8 write_seed;
+  uint8 read_seed;
+  uint8 write_seed;
 
   int bytes_to_send;
   int bytes_to_read;

Modified: trafficserver/traffic/trunk/iocore/net/P_SSLNetVConnection.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/P_SSLNetVConnection.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/P_SSLNetVConnection.h (original)
+++ trafficserver/traffic/trunk/iocore/net/P_SSLNetVConnection.h Wed May 19 21:06:35 2010
@@ -106,7 +106,7 @@ public:
   int sslServerHandShakeEvent(int &err);
   int sslClientHandShakeEvent(int &err);
   virtual void net_read_io(NetHandler * nh, EThread * lthread);
-  virtual ink64 load_buffer_and_write(ink64 towrite, ink64 &wattempted, ink64 &total_wrote, MIOBufferAccessor & buf);
+  virtual int64 load_buffer_and_write(int64 towrite, int64 &wattempted, int64 &total_wrote, MIOBufferAccessor & buf);
   virtual ~ SSLNetVConnection() { }
   ////////////////////////////////////////////////////////////
   // instances of NetVConnection should be allocated        //

Modified: trafficserver/traffic/trunk/iocore/net/P_UDPConnection.h
URL: http://svn.apache.org/viewvc/trafficserver/traffic/trunk/iocore/net/P_UDPConnection.h?rev=946395&r1=946394&r2=946395&view=diff
==============================================================================
--- trafficserver/traffic/trunk/iocore/net/P_UDPConnection.h (original)
+++ trafficserver/traffic/trunk/iocore/net/P_UDPConnection.h Wed May 19 21:06:35 2010
@@ -50,7 +50,7 @@ public:
   int binding_valid;
   int tobedestroyed;
   int sendGenerationNum;
-  ink64 lastSentPktTSSeqNum;
+  int64 lastSentPktTSSeqNum;
 
   // this is for doing packet scheduling: we keep two values so that we can
   // implement cancel.  The first value tracks the startTime of the last
@@ -58,15 +58,15 @@ public:
   // startTime of the last packet when we are doing scheduling;  whenever the
   // associated continuation cancels a packet, we rest lastPktStartTime to be
   // the same as the lastSentPktStartTime.
-  inku64 lastSentPktStartTime;
-  inku64 lastPktStartTime;
-  ink32 pipe_class;
-  inku32 nBytesDone;
-  inku32 nBytesTodo;
+  uint64 lastSentPktStartTime;
+  uint64 lastPktStartTime;
+  int32 pipe_class;
+  uint32 nBytesDone;
+  uint32 nBytesTodo;
   // flow rate in Bytes per sec.
   double flowRateBps;
   double avgPktSize;
-  ink64 allocedbps;
+  int64 allocedbps;
 
   //this class is abstract
 };
@@ -180,7 +180,7 @@ UDPConnection::getPortNum(void)
   return ((UDPConnectionInternal *) this)->binding.sin_port;
 }
 
-TS_INLINE ink64
+TS_INLINE int64
 UDPConnection::cancel(void)
 {
   UDPConnectionInternal *p = (UDPConnectionInternal *) this;
@@ -191,7 +191,7 @@ UDPConnection::cancel(void)
 };
 
 TS_INLINE void
-UDPConnection::SetLastSentPktTSSeqNum(ink64 sentSeqNum)
+UDPConnection::SetLastSentPktTSSeqNum(int64 sentSeqNum)
 {
   ((UDPConnectionInternal *) this)->lastSentPktTSSeqNum = sentSeqNum;
 };