ApacheTrafficServer: InkIOCoreAPI.cc Source File

Go to the documentation of this file.
00001 /** @file
00002 
00003   A brief file description
00004 
00005   @section license License
00006 
00007   Licensed to the Apache Software Foundation (ASF) under one
00008   or more contributor license agreements.  See the NOTICE file
00009   distributed with this work for additional information
00010   regarding copyright ownership.  The ASF licenses this file
00011   to you under the Apache License, Version 2.0 (the
00012   "License"); you may not use this file except in compliance
00013   with the License.  You may obtain a copy of the License at
00014 
00015       http://www.apache.org/licenses/LICENSE-2.0
00016 
00017   Unless required by applicable law or agreed to in writing, software
00018   distributed under the License is distributed on an "AS IS" BASIS,
00019   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00020   See the License for the specific language governing permissions and
00021   limitations under the License.
00022  */
00023 
00024 /*
00025  * This file contains all the functions exported by the IOCore to the SDK.
00026  * Any IOCore symbol accessed by a plugin directly should be called in this
00027  * file to ensure that it gets exported as a global symbol in TS
00028  */
00029 
00030 #include "libts.h"
00031 #include "api/ts/InkAPIPrivateIOCore.h"
00032 #if defined(solaris) && !defined(__GNUC__)
00033 #include "P_EventSystem.h" // I_EventSystem.h
00034 #include "P_Net.h"         // I_Net.h
00035 #else
00036 #include "I_EventSystem.h"
00037 #include "I_Net.h"
00038 #endif
00039 #include "I_Cache.h"
00040 #include "I_HostDB.h"
00041 
00042 // This assert is for internal API use only.
00043 #if TS_USE_FAST_SDK
00044 #define sdk_assert(EX) (void)(EX)
00045 #else
00046 #define sdk_assert(EX)                                          \
00047   ( (void)((EX) ? (void)0 : _TSReleaseAssert(#EX, __FILE__, __LINE__)) )
00048 #endif
00049 
00050 
00051 TSReturnCode
00052 sdk_sanity_check_mutex(TSMutex mutex)
00053 {
00054   if (mutex == NULL)
00055     return TS_ERROR;
00056 
00057   ProxyMutex *mutexp = (ProxyMutex *) mutex;
00058 
00059   if (mutexp->m_refcount < 0)
00060     return TS_ERROR;
00061   if (mutexp->nthread_holding < 0)
00062     return TS_ERROR;
00063 
00064   return TS_SUCCESS;
00065 }
00066 
00067 
00068 TSReturnCode
00069 sdk_sanity_check_hostlookup_structure(TSHostLookupResult data)
00070 {
00071   if (data == NULL)
00072     return TS_ERROR;
00073 
00074   return TS_SUCCESS;
00075 }
00076 
00077 TSReturnCode
00078 sdk_sanity_check_iocore_structure(void *data)
00079 {
00080   if (data == NULL)
00081     return TS_ERROR;
00082 
00083   return TS_SUCCESS;
00084 }
00085 
00086 // From InkAPI.cc
00087 TSReturnCode sdk_sanity_check_continuation(TSCont cont);
00088 TSReturnCode sdk_sanity_check_null_ptr(void *ptr);
00089 
00090 
00091 ////////////////////////////////////////////////////////////////////
00092 //
00093 // Threads
00094 //
00095 ////////////////////////////////////////////////////////////////////
00096 struct INKThreadInternal:public EThread
00097 {
00098   INKThreadInternal()
00099     : EThread(DEDICATED, -1)
00100   {  }
00101 
00102   TSThreadFunc func;
00103   void *data;
00104 };
00105 
00106 static void *
00107 ink_thread_trampoline(void *data)
00108 {
00109   INKThreadInternal *thread;
00110   void *retval;
00111 
00112   thread = (INKThreadInternal *) data;
00113   thread->set_specific();
00114   retval = thread->func(thread->data);
00115   delete thread;
00116 
00117   return retval;
00118 }
00119 
00120 /*
00121  * INKqa12653. Return TSThread or NULL if error
00122  */
00123 TSThread
00124 TSThreadCreate(TSThreadFunc func, void *data)
00125 {
00126   INKThreadInternal *thread;
00127 
00128   thread = new INKThreadInternal;
00129 
00130   ink_assert(thread->event_types == 0);
00131 
00132   thread->func = func;
00133   thread->data = data;
00134 
00135   if (!(ink_thread_create(ink_thread_trampoline, (void *)thread, 1))) {
00136     return (TSThread)NULL;
00137   }
00138 
00139   return (TSThread)thread;
00140 }
00141 
00142 TSThread
00143 TSThreadInit()
00144 {
00145   INKThreadInternal *thread;
00146 
00147   thread = new INKThreadInternal;
00148 
00149 #ifdef DEBUG
00150   if (thread == NULL)
00151     return (TSThread)NULL;
00152 #endif
00153 
00154   thread->set_specific();
00155 
00156   return reinterpret_cast<TSThread>(thread);
00157 }
00158 
00159 void
00160 TSThreadDestroy(TSThread thread)
00161 {
00162   sdk_assert(sdk_sanity_check_iocore_structure(thread) == TS_SUCCESS);
00163 
00164   INKThreadInternal *ithread = (INKThreadInternal *)thread;
00165   delete ithread;
00166 }
00167 
00168 TSThread
00169 TSThreadSelf(void)
00170 {
00171   TSThread ithread = (TSThread)this_ethread();
00172   return ithread;
00173 }
00174 
00175 
00176 ////////////////////////////////////////////////////////////////////
00177 //
00178 // Mutexes
00179 //
00180 ////////////////////////////////////////////////////////////////////
00181 TSMutex
00182 TSMutexCreate()
00183 {
00184   ProxyMutex *mutexp = new_ProxyMutex();
00185 
00186   // TODO: Remove this when allocations can never fail.
00187   sdk_assert(sdk_sanity_check_mutex((TSMutex)mutexp) == TS_SUCCESS);
00188 
00189   return (TSMutex)mutexp;
00190 }
00191 
00192 /* The following two APIs are for Into work, actually, APIs of Mutex
00193    should allow plugins to manually increase or decrease the refcount
00194    of the mutex pointer, plugins may want more control of the creation
00195    and destroy of the mutex.*/
00196 TSMutex
00197 TSMutexCreateInternal()
00198 {
00199   ProxyMutex *new_mutex = new_ProxyMutex();
00200 
00201   // TODO: Remove this when allocations can never fail.
00202   sdk_assert(sdk_sanity_check_mutex((TSMutex)new_mutex) == TS_SUCCESS);
00203 
00204   new_mutex->refcount_inc();
00205   return reinterpret_cast<TSMutex>(new_mutex);
00206 }
00207 
00208 int
00209 TSMutexCheck(TSMutex mutex)
00210 {
00211   ProxyMutex *mutexp = (ProxyMutex *)mutex;
00212 
00213   if (mutexp->m_refcount < 0)
00214     return -1;
00215   if (mutexp->nthread_holding < 0)
00216     return -1;
00217   return 1;
00218 }
00219 
00220 void
00221 TSMutexLock(TSMutex mutexp)
00222 {
00223   sdk_assert(sdk_sanity_check_mutex(mutexp) == TS_SUCCESS);
00224   MUTEX_TAKE_LOCK((ProxyMutex *)mutexp, this_ethread());
00225 }
00226 
00227 
00228 TSReturnCode
00229 TSMutexLockTry(TSMutex mutexp)
00230 {
00231   sdk_assert(sdk_sanity_check_mutex(mutexp) == TS_SUCCESS);
00232   return (MUTEX_TAKE_TRY_LOCK((ProxyMutex *)mutexp, this_ethread()) ? TS_SUCCESS : TS_ERROR);
00233 }
00234 
00235 void
00236 TSMutexUnlock(TSMutex mutexp)
00237 {
00238   sdk_assert(sdk_sanity_check_mutex(mutexp) == TS_SUCCESS);
00239   MUTEX_UNTAKE_LOCK((ProxyMutex *)mutexp, this_ethread());
00240 }
00241 
00242 /* VIOs */
00243 
00244 void
00245 TSVIOReenable(TSVIO viop)
00246 {
00247   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00248 
00249   VIO *vio = (VIO *)viop;
00250   vio->reenable();
00251 }
00252 
00253 TSIOBuffer
00254 TSVIOBufferGet(TSVIO viop)
00255 {
00256   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00257 
00258   VIO *vio = (VIO *)viop;
00259   return reinterpret_cast<TSIOBuffer>(vio->get_writer());
00260 }
00261 
00262 TSIOBufferReader
00263 TSVIOReaderGet(TSVIO viop)
00264 {
00265   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00266 
00267   VIO *vio = (VIO *)viop;
00268   return reinterpret_cast<TSIOBufferReader>(vio->get_reader());
00269 }
00270 
00271 int64_t
00272 TSVIONBytesGet(TSVIO viop)
00273 {
00274   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00275 
00276   VIO *vio = (VIO *)viop;
00277   return vio->nbytes;
00278 }
00279 
00280 void
00281 TSVIONBytesSet(TSVIO viop, int64_t nbytes)
00282 {
00283   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00284   sdk_assert(nbytes >= 0);
00285 
00286   VIO *vio = (VIO *)viop;
00287   vio->nbytes = nbytes;
00288 }
00289 
00290 int64_t
00291 TSVIONDoneGet(TSVIO viop)
00292 {
00293   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00294 
00295   VIO *vio = (VIO *)viop;
00296   return vio->ndone;
00297 }
00298 
00299 void
00300 TSVIONDoneSet(TSVIO viop, int64_t ndone)
00301 {
00302   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00303   sdk_assert(ndone >= 0);
00304 
00305   VIO *vio = (VIO *)viop;
00306   vio->ndone = ndone;
00307 }
00308 
00309 int64_t
00310 TSVIONTodoGet(TSVIO viop)
00311 {
00312   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00313 
00314   VIO *vio = (VIO *)viop;
00315   return vio->ntodo();
00316 }
00317 
00318 TSCont
00319 TSVIOContGet(TSVIO viop)
00320 {
00321   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00322 
00323   VIO *vio = (VIO *)viop;
00324   return (TSCont) vio->_cont;
00325 }
00326 
00327 TSVConn
00328 TSVIOVConnGet(TSVIO viop)
00329 {
00330   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00331 
00332   VIO *vio = (VIO *)viop;
00333   return (TSVConn)vio->vc_server;
00334 }
00335 
00336 TSMutex
00337 TSVIOMutexGet(TSVIO viop)
00338 {
00339   sdk_assert(sdk_sanity_check_iocore_structure(viop) == TS_SUCCESS);
00340 
00341   VIO *vio = (VIO *)viop;
00342   return (TSMutex)((ProxyMutex *)vio->mutex);
00343 }
00344 
00345 /* High Resolution Time */
00346 
00347 ink_hrtime
00348 INKBasedTimeGet()
00349 {
00350   return ink_get_based_hrtime();
00351 }
00352 
00353 /* UDP Connection Interface */
00354 
00355 TSAction
00356 INKUDPBind(TSCont contp, unsigned int ip, int port)
00357 {  
00358   sdk_assert(sdk_sanity_check_continuation(contp) == TS_SUCCESS);
00359     
00360   FORCE_PLUGIN_MUTEX(contp);
00361 
00362   struct sockaddr_in addr;
00363   ats_ip4_set(&addr, ip, htons(port));
00364   
00365   return reinterpret_cast<TSAction>(udpNet.UDPBind((Continuation *)contp, ats_ip_sa_cast(&addr), INK_ETHERNET_MTU_SIZE, INK_ETHERNET_MTU_SIZE));
00366 }
00367 
00368 TSAction
00369 INKUDPSendTo(TSCont contp, INKUDPConn udp, unsigned int ip, int port, char *data, int64_t len)
00370 {
00371   sdk_assert(sdk_sanity_check_continuation(contp) == TS_SUCCESS);
00372 
00373   FORCE_PLUGIN_MUTEX(contp);
00374   UDPPacket *packet = new_UDPPacket();
00375   UDPConnection *conn = (UDPConnection *)udp;
00376 
00377   ats_ip4_set(&packet->to, ip, htons(port));
00378 
00379   IOBufferBlock *blockp = new_IOBufferBlock();
00380   blockp->alloc(BUFFER_SIZE_INDEX_32K);
00381 
00382   if (len > index_to_buffer_size(BUFFER_SIZE_INDEX_32K)) {
00383     len = index_to_buffer_size(BUFFER_SIZE_INDEX_32K) - 1;
00384   }
00385 
00386   memcpy(blockp->start(), data, len);
00387   blockp->fill(len);
00388 
00389   packet->append_block((IOBufferBlock *)blockp);
00390   /* (Jinsheng 11/27/00) set connection twice which causes:
00391      FATAL: ../../../proxy/iocore/UDPPacket.h:136:
00392      failed assert `!m_conn` */
00393 
00394   /* packet->setConnection ((UDPConnection *)udp); */
00395   return reinterpret_cast<TSAction>(conn->send((Continuation *)contp, packet));
00396 }
00397 
00398 
00399 TSAction
00400 INKUDPRecvFrom(TSCont contp, INKUDPConn udp)
00401 {
00402   sdk_assert(sdk_sanity_check_continuation(contp) == TS_SUCCESS);
00403 
00404   FORCE_PLUGIN_MUTEX(contp);
00405   UDPConnection *conn = (UDPConnection *)udp;
00406   return reinterpret_cast<TSAction>(conn->recv((Continuation *)contp));
00407 }
00408 
00409 int
00410 INKUDPConnFdGet(INKUDPConn udp)
00411 {
00412   UDPConnection *conn = (UDPConnection *)udp;
00413   return conn->getFd();
00414 }
00415 
00416 /* UDP Packet */
00417 INKUDPPacket
00418 INKUDPPacketCreate()
00419 {
00420   UDPPacket *packet = new_UDPPacket();
00421   return ((INKUDPPacket)packet);
00422 }
00423 
00424 TSIOBufferBlock
00425 INKUDPPacketBufferBlockGet(INKUDPPacket packet)
00426 {
00427   sdk_assert(sdk_sanity_check_null_ptr((void*)packet) == TS_SUCCESS);
00428 
00429   UDPPacket *p = (UDPPacket *)packet;
00430   return ((TSIOBufferBlock)p->getIOBlockChain());
00431 }
00432 
00433 unsigned int
00434 INKUDPPacketFromAddressGet(INKUDPPacket packet)
00435 {
00436   sdk_assert(sdk_sanity_check_null_ptr((void*)packet) == TS_SUCCESS);
00437 
00438   UDPPacket *p = (UDPPacket *)packet;
00439   return ats_ip4_addr_cast(&p->from);
00440 }
00441 
00442 int
00443 INKUDPPacketFromPortGet(INKUDPPacket packet)
00444 {
00445   sdk_assert(sdk_sanity_check_null_ptr((void*)packet) == TS_SUCCESS);
00446 
00447   UDPPacket *p = (UDPPacket *)packet;
00448   return ats_ip_port_host_order(&p->from);
00449 }
00450 
00451 INKUDPConn
00452 INKUDPPacketConnGet(INKUDPPacket packet)
00453 {
00454   sdk_assert(sdk_sanity_check_null_ptr((void*)packet) == TS_SUCCESS);
00455 
00456   UDPPacket *p = (UDPPacket *)packet;
00457   return ((INKUDPConn)p->getConnection());
00458 }
00459 
00460 void
00461 INKUDPPacketDestroy(INKUDPPacket packet)
00462 {
00463   sdk_assert(sdk_sanity_check_null_ptr((void*)packet) == TS_SUCCESS);
00464 
00465   UDPPacket *p = (UDPPacket *)packet;
00466   p->free();
00467 }
00468 
00469 /* Packet Queue */
00470 
00471 INKUDPPacket
00472 INKUDPPacketGet(INKUDPacketQueue queuep)
00473 {
00474   if (queuep != NULL) {
00475     UDPPacket *packet;
00476     Queue<UDPPacket> *qp = (Queue<UDPPacket> *)queuep;
00477 
00478     packet = qp->pop();
00479     return (packet);
00480   } 
00481 
00482   return NULL;
00483 }
00484 
00485 
00486 /* Buffers */
00487 
00488 TSIOBuffer
00489 TSIOBufferCreate()
00490 {
00491   MIOBuffer *b = new_empty_MIOBuffer();
00492 
00493   // TODO: Should remove this when memory allocations can't fail.
00494   sdk_assert(sdk_sanity_check_iocore_structure(b) == TS_SUCCESS);
00495   return reinterpret_cast<TSIOBuffer>(b);
00496 }
00497 
00498 TSIOBuffer
00499 TSIOBufferSizedCreate(TSIOBufferSizeIndex index)
00500 {
00501   sdk_assert((index >= TS_IOBUFFER_SIZE_INDEX_128) && (index <= TS_IOBUFFER_SIZE_INDEX_32K));
00502 
00503   MIOBuffer *b = new_MIOBuffer(index);
00504 
00505   // TODO: Should remove this when memory allocations can't fail.
00506   sdk_assert(sdk_sanity_check_iocore_structure(b) == TS_SUCCESS);
00507   return reinterpret_cast<TSIOBuffer>(b);
00508 }
00509 
00510 void
00511 TSIOBufferDestroy(TSIOBuffer bufp)
00512 {
00513   sdk_assert(sdk_sanity_check_iocore_structure(bufp) == TS_SUCCESS);
00514   free_MIOBuffer((MIOBuffer *)bufp);
00515 }
00516 
00517 TSIOBufferBlock
00518 TSIOBufferStart(TSIOBuffer bufp)
00519 {
00520   sdk_assert(sdk_sanity_check_iocore_structure(bufp) == TS_SUCCESS);
00521 
00522   MIOBuffer *b = (MIOBuffer *)bufp;
00523   IOBufferBlock *blk = b->get_current_block();
00524 
00525   if (!blk || (blk->write_avail() == 0))
00526     b->add_block();
00527   blk = b->get_current_block();
00528 
00529   // TODO: Remove when memory allocations can't fail.
00530   sdk_assert(sdk_sanity_check_null_ptr((void*)blk) == TS_SUCCESS);
00531 
00532   return (TSIOBufferBlock)blk;
00533 }
00534 
00535 int64_t
00536 TSIOBufferCopy(TSIOBuffer bufp, TSIOBufferReader readerp, int64_t length, int64_t offset)
00537 {
00538   sdk_assert(sdk_sanity_check_iocore_structure(bufp) == TS_SUCCESS);
00539   sdk_assert(sdk_sanity_check_iocore_structure(readerp) == TS_SUCCESS);
00540   sdk_assert((length >= 0) && (offset >= 0));
00541 
00542   MIOBuffer *b = (MIOBuffer *)bufp;
00543   IOBufferReader *r = (IOBufferReader *)readerp;
00544 
00545   return b->write(r, length, offset);
00546 }
00547 
00548 int64_t
00549 TSIOBufferWrite(TSIOBuffer bufp, const void *buf, int64_t length)
00550 {
00551   sdk_assert(sdk_sanity_check_iocore_structure(bufp) == TS_SUCCESS);
00552   sdk_assert(sdk_sanity_check_null_ptr((void*)buf) == TS_SUCCESS);
00553   sdk_assert(length >= 0);
00554 
00555   MIOBuffer *b = (MIOBuffer *)bufp;
00556   return b->write(buf, length);
00557 }
00558 
00559 // not in SDK3.0
00560 void
00561 TSIOBufferReaderCopy(TSIOBufferReader readerp, const void *buf, int64_t length)
00562 {
00563   IOBufferReader *r = (IOBufferReader *)readerp;
00564   r->memcpy(buf, length);
00565 }
00566 
00567 void
00568 TSIOBufferProduce(TSIOBuffer bufp, int64_t nbytes)
00569 {
00570   sdk_assert(sdk_sanity_check_iocore_structure(bufp) == TS_SUCCESS);
00571   sdk_assert(nbytes >= 0);
00572 
00573   MIOBuffer *b = (MIOBuffer *)bufp;
00574   b->fill(nbytes);
00575 }
00576 
00577 // dev API, not exposed
00578 void
00579 TSIOBufferBlockDestroy(TSIOBufferBlock blockp)
00580 {
00581   sdk_assert(sdk_sanity_check_iocore_structure(blockp) == TS_SUCCESS);
00582 
00583   IOBufferBlock *blk = (IOBufferBlock *)blockp;
00584   blk->free();
00585 }
00586 
00587 TSIOBufferBlock
00588 TSIOBufferBlockNext(TSIOBufferBlock blockp)
00589 {
00590   sdk_assert(sdk_sanity_check_iocore_structure(blockp) == TS_SUCCESS);
00591 
00592   IOBufferBlock *blk = (IOBufferBlock *)blockp;
00593   return (TSIOBufferBlock)((IOBufferBlock *)blk->next);
00594 }
00595 
00596 // dev API, not exposed
00597 int64_t
00598 TSIOBufferBlockDataSizeGet(TSIOBufferBlock blockp)
00599 {
00600   sdk_assert(sdk_sanity_check_iocore_structure(blockp) == TS_SUCCESS);
00601 
00602   IOBufferBlock *blk = (IOBufferBlock *)blockp;
00603   return (blk->read_avail());
00604 }
00605 
00606 const char *
00607 TSIOBufferBlockReadStart(TSIOBufferBlock blockp, TSIOBufferReader readerp, int64_t *avail)
00608 {
00609   sdk_assert(sdk_sanity_check_iocore_structure(blockp) == TS_SUCCESS);
00610   sdk_assert(sdk_sanity_check_iocore_structure(readerp) == TS_SUCCESS);
00611 
00612   IOBufferBlock *blk = (IOBufferBlock *)blockp;
00613   IOBufferReader *reader = (IOBufferReader *)readerp;
00614   char *p;
00615 
00616   p = blk->start();
00617   if (avail)
00618     *avail = blk->read_avail();
00619 
00620   if (blk == reader->block) {
00621     p += reader->start_offset;
00622     if (avail) {
00623       *avail -= reader->start_offset;
00624       if (*avail < 0) {
00625         *avail = 0;
00626       }
00627     }
00628   }
00629 
00630   return (const char *)p;
00631 }
00632 
00633 int64_t
00634 TSIOBufferBlockReadAvail(TSIOBufferBlock blockp, TSIOBufferReader readerp)
00635 {
00636   sdk_assert(sdk_sanity_check_iocore_structure(blockp) == TS_SUCCESS);
00637   sdk_assert(sdk_sanity_check_iocore_structure(readerp) == TS_SUCCESS);
00638 
00639   IOBufferBlock *blk = (IOBufferBlock *)blockp;
00640   IOBufferReader *reader = (IOBufferReader *)readerp;
00641   int64_t avail;
00642 
00643   avail = blk->read_avail();
00644 
00645   if (blk == reader->block) {
00646     avail -= reader->start_offset;
00647     if (avail < 0) {
00648       avail = 0;
00649     }
00650   }
00651 
00652   return avail;
00653 }
00654 
00655 char *
00656 TSIOBufferBlockWriteStart(TSIOBufferBlock blockp, int64_t *avail)
00657 {
00658   sdk_assert(sdk_sanity_check_iocore_structure(blockp) == TS_SUCCESS);
00659 
00660   IOBufferBlock *blk = (IOBufferBlock *)blockp;
00661 
00662   if (avail)
00663     *avail = blk->write_avail();
00664   return blk->end();
00665 }
00666 
00667 int64_t
00668 TSIOBufferBlockWriteAvail(TSIOBufferBlock blockp)
00669 {
00670   sdk_assert(sdk_sanity_check_iocore_structure(blockp) == TS_SUCCESS);
00671 
00672   IOBufferBlock *blk = (IOBufferBlock *)blockp;
00673   return blk->write_avail();
00674 }
00675 
00676 int64_t
00677 TSIOBufferWaterMarkGet(TSIOBuffer bufp)
00678 {
00679   sdk_assert(sdk_sanity_check_iocore_structure(bufp) == TS_SUCCESS);
00680 
00681   MIOBuffer *b = (MIOBuffer *)bufp;
00682   return b->water_mark;
00683 }
00684 
00685 void
00686 TSIOBufferWaterMarkSet(TSIOBuffer bufp, int64_t water_mark)
00687 {
00688   sdk_assert(sdk_sanity_check_iocore_structure(bufp) == TS_SUCCESS);
00689   sdk_assert(water_mark >= 0);
00690 
00691   MIOBuffer *b = (MIOBuffer *)bufp;
00692   b->water_mark = water_mark;
00693 }
00694 
00695 TSIOBufferReader
00696 TSIOBufferReaderAlloc(TSIOBuffer bufp)
00697 {
00698   sdk_assert(sdk_sanity_check_iocore_structure(bufp) == TS_SUCCESS);
00699 
00700   MIOBuffer *b = (MIOBuffer *)bufp;
00701   TSIOBufferReader readerp = (TSIOBufferReader)b->alloc_reader();
00702 
00703   // TODO: Should remove this when memory allocation can't fail.
00704   sdk_assert(sdk_sanity_check_null_ptr((void*)readerp) == TS_SUCCESS);
00705   return readerp;
00706 }
00707 
00708 TSIOBufferReader
00709 TSIOBufferReaderClone(TSIOBufferReader readerp)
00710 {
00711   sdk_assert(sdk_sanity_check_iocore_structure(readerp) == TS_SUCCESS);
00712 
00713   IOBufferReader *r = (IOBufferReader *)readerp;
00714   return (TSIOBufferReader)r->clone();
00715 }
00716 
00717 void
00718 TSIOBufferReaderFree(TSIOBufferReader readerp)
00719 {
00720   sdk_assert(sdk_sanity_check_iocore_structure(readerp) == TS_SUCCESS);
00721 
00722   IOBufferReader *r = (IOBufferReader *)readerp;
00723   r->mbuf->dealloc_reader(r);
00724 }
00725 
00726 TSIOBufferBlock
00727 TSIOBufferReaderStart(TSIOBufferReader readerp)
00728 {
00729   sdk_assert(sdk_sanity_check_iocore_structure(readerp) == TS_SUCCESS);
00730 
00731   IOBufferReader *r = (IOBufferReader *)readerp;
00732 
00733   if (r->block != NULL)
00734     r->skip_empty_blocks();
00735   return reinterpret_cast<TSIOBufferBlock>(r->get_current_block());
00736 }
00737 
00738 void
00739 TSIOBufferReaderConsume(TSIOBufferReader readerp, int64_t nbytes)
00740 {
00741   sdk_assert(sdk_sanity_check_iocore_structure(readerp) == TS_SUCCESS);
00742   sdk_assert(nbytes >= 0);
00743 
00744   IOBufferReader *r = (IOBufferReader *)readerp;
00745   r->consume(nbytes);
00746 }
00747 
00748 int64_t
00749 TSIOBufferReaderAvail(TSIOBufferReader readerp)
00750 {
00751   sdk_assert(sdk_sanity_check_iocore_structure(readerp) == TS_SUCCESS);
00752 
00753   IOBufferReader *r = (IOBufferReader *)readerp;
00754   return r->read_avail();
00755 }