iolayer.c

Go to the documentation of this file.
00001 /***************************************************************************
00002  $RCSfile$
00003                              -------------------
00004     cvs         : $Id: crypttoken.h 1113 2007-01-10 09:14:16Z martin $
00005     begin       : Wed Mar 16 2005
00006     copyright   : (C) 2005 by Martin Preuss
00007     email       : martin@libchipcard.de
00008 
00009  ***************************************************************************
00010  *          Please see toplevel file COPYING for license details           *
00011  ***************************************************************************/
00012 
00013 #ifdef HAVE_CONFIG_H
00014 # include <config.h>
00015 #endif
00016 
00017 
00018 #include "iolayer_p.h"
00019 #include "iorequest_l.h"
00020 
00021 #include "i18n_l.h"
00022 #include <gwenhywfar/misc.h>
00023 #include <gwenhywfar/debug.h>
00024 #include <gwenhywfar/gui.h>
00025 #include <gwenhywfar/iomanager.h>
00026 
00027 #include <assert.h>
00028 
00029 
00030 
00031 GWEN_INHERIT_FUNCTIONS(GWEN_IO_LAYER)
00032 GWEN_LIST_FUNCTIONS(GWEN_IO_LAYER, GWEN_Io_Layer)
00033 GWEN_LIST2_FUNCTIONS(GWEN_IO_LAYER, GWEN_Io_Layer)
00034 
00035 
00036 
00037 
00038 
00039 GWEN_IO_LAYER *GWEN_Io_Layer_new(const char *typeName, GWEN_IO_LAYER *baseLayer) {
00040   GWEN_IO_LAYER *io;
00041 
00042   assert(typeName);
00043   GWEN_NEW_OBJECT(GWEN_IO_LAYER, io);
00044   io->refCount=1;
00045   GWEN_INHERIT_INIT(GWEN_IO_LAYER, io);
00046   GWEN_LIST_INIT(GWEN_IO_LAYER, io);
00047 
00048   io->typeName=strdup(typeName);
00049   if (baseLayer) {
00050     io->baseLayer=baseLayer;
00051     GWEN_Io_Layer_Attach(io->baseLayer);
00052   }
00053 
00054   io->incomingLayers=GWEN_Io_Layer_List_new();
00055 
00056   return io;
00057 }
00058 
00059 
00060 
00061 void GWEN_Io_Layer_Attach(GWEN_IO_LAYER *io) {
00062   assert(io);
00063   assert(io->refCount);
00064   io->refCount++;
00065 }
00066 
00067 
00068 
00069 void GWEN_Io_Layer_free(GWEN_IO_LAYER *io) {
00070   if (io) {
00071     assert(io->refCount);
00072     if (io->refCount==1) {
00073       GWEN_LIST_FINI(GWEN_IO_LAYER, io);
00074       GWEN_INHERIT_FINI(GWEN_IO_LAYER, io);
00075       GWEN_Io_Layer_List_free(io->incomingLayers);
00076       GWEN_Io_Layer_free(io->baseLayer);
00077       free(io->typeName);
00078       io->refCount=0;
00079       GWEN_FREE_OBJECT(io);
00080     }
00081     else
00082       io->refCount--;
00083   }
00084 }
00085 
00086 
00087 
00088 GWEN_IO_LAYER *GWEN_Io_Layer_GetBaseLayer(GWEN_IO_LAYER *io) {
00089   assert(io);
00090   assert(io->refCount);
00091 
00092   return io->baseLayer;
00093 }
00094 
00095 
00096 
00097 GWEN_IO_LAYER *GWEN_Io_Layer_FindBaseLayerByType(GWEN_IO_LAYER *io, const char *tname) {
00098   assert(io);
00099   assert(io->refCount);
00100 
00101   assert(tname);
00102 
00103   while(io) {
00104     if (strcasecmp(io->typeName, tname)==0)
00105       break;
00106     io=io->baseLayer;
00107   }
00108 
00109   return io;
00110 }
00111 
00112 
00113 
00114 void GWEN_Io_Layer_AddIncomingLayer(GWEN_IO_LAYER *io, GWEN_IO_LAYER *newIo) {
00115   assert(io);
00116   assert(io->refCount);
00117   assert(newIo);
00118   assert(newIo->refCount);
00119 
00120   GWEN_Io_Layer_List_Add(newIo, io->incomingLayers);
00121 }
00122 
00123 
00124 
00125 GWEN_IO_LAYER *GWEN_Io_Layer_GetNextIncomingLayer(GWEN_IO_LAYER *io) {
00126   GWEN_IO_LAYER *newIo;
00127 
00128   assert(io);
00129   assert(io->refCount);
00130 
00131   newIo=GWEN_Io_Layer_List_First(io->incomingLayers);
00132   if (newIo)
00133     GWEN_Io_Layer_List_Del(newIo);
00134   return newIo;
00135 }
00136 
00137 
00138 
00139 void GWEN_Io_Layer_ClearIncomingLayers(GWEN_IO_LAYER *io) {
00140   assert(io);
00141   assert(io->refCount);
00142 
00143   GWEN_Io_Layer_List_Clear(io->incomingLayers);
00144 }
00145 
00146 
00147 
00148 const char *GWEN_Io_Layer_GetTypeName(const GWEN_IO_LAYER *io) {
00149   assert(io);
00150   assert(io->refCount);
00151 
00152   return io->typeName;
00153 }
00154 
00155 
00156 
00157 uint32_t GWEN_Io_Layer_GetFlags(const GWEN_IO_LAYER *io) {
00158   assert(io);
00159   assert(io->refCount);
00160 
00161   return io->flags;
00162 }
00163 
00164 
00165 
00166 void GWEN_Io_Layer_SetFlags(GWEN_IO_LAYER *io, uint32_t f) {
00167   assert(io);
00168   assert(io->refCount);
00169 
00170   io->flags=f;
00171 }
00172 
00173 
00174 
00175 void GWEN_Io_Layer_AddFlags(GWEN_IO_LAYER *io, uint32_t f) {
00176   assert(io);
00177   assert(io->refCount);
00178 
00179   io->flags|=f;
00180 }
00181 
00182 
00183 
00184 void GWEN_Io_Layer_SubFlags(GWEN_IO_LAYER *io, uint32_t f) {
00185   assert(io);
00186   assert(io->refCount);
00187 
00188   io->flags&=~f;
00189 }
00190 
00191 
00192 
00193 GWEN_IO_LAYER_STATUS GWEN_Io_Layer_GetStatus(const GWEN_IO_LAYER *io) {
00194   assert(io);
00195   assert(io->refCount);
00196 
00197   return io->status;
00198 }
00199 
00200 
00201 
00202 void GWEN_Io_Layer_SetStatus(GWEN_IO_LAYER *io, GWEN_IO_LAYER_STATUS st) {
00203   assert(io);
00204   assert(io->refCount);
00205 
00206   io->status=st;
00207 }
00208 
00209 
00210 
00211 GWEN_IO_LAYER_WORKONREQUESTS_FN GWEN_Io_Layer_SetWorkOnRequestsFn(GWEN_IO_LAYER *io, GWEN_IO_LAYER_WORKONREQUESTS_FN f) {
00212   GWEN_IO_LAYER_WORKONREQUESTS_FN of;
00213 
00214   assert(io);
00215   assert(io->refCount);
00216 
00217   of=io->workOnRequestsFn;
00218   io->workOnRequestsFn=f;
00219 
00220   return of;
00221 }
00222 
00223 
00224 
00225 GWEN_IO_LAYER_ADDREQUEST_FN GWEN_Io_Layer_SetAddRequestFn(GWEN_IO_LAYER *io, GWEN_IO_LAYER_ADDREQUEST_FN f) {
00226   GWEN_IO_LAYER_ADDREQUEST_FN of;
00227 
00228   assert(io);
00229   assert(io->refCount);
00230 
00231   of=io->addRequestFn;
00232   io->addRequestFn=f;
00233 
00234   return of;
00235 }
00236 
00237 
00238 
00239 GWEN_IO_LAYER_DELREQUEST_FN GWEN_Io_Layer_SetDelRequestFn(GWEN_IO_LAYER *io, GWEN_IO_LAYER_DELREQUEST_FN f) {
00240   GWEN_IO_LAYER_DELREQUEST_FN of;
00241 
00242   assert(io);
00243   assert(io->refCount);
00244 
00245   of=io->delRequestFn;
00246   io->delRequestFn=f;
00247 
00248   return of;
00249 }
00250 
00251 
00252 
00253 GWEN_IO_LAYER_HASWAITINGREQUESTS_FN GWEN_Io_Layer_SetHasWaitingRequestsFn(GWEN_IO_LAYER *io,
00254                                                                           GWEN_IO_LAYER_HASWAITINGREQUESTS_FN f) {
00255   GWEN_IO_LAYER_HASWAITINGREQUESTS_FN of;
00256 
00257   assert(io);
00258   assert(io->refCount);
00259 
00260   of=io->hasWaitingRequestsFn;
00261   io->hasWaitingRequestsFn=f;
00262 
00263   return of;
00264 }
00265 
00266 
00267 
00268 GWEN_IO_LAYER_ADDWAITINGSOCKETS_FN GWEN_Io_Layer_SetAddWaitingSocketsFn(GWEN_IO_LAYER *io,
00269                                                                         GWEN_IO_LAYER_ADDWAITINGSOCKETS_FN f) {
00270   GWEN_IO_LAYER_ADDWAITINGSOCKETS_FN of;
00271 
00272   assert(io);
00273   assert(io->refCount);
00274 
00275   of=io->addWaitingSocketsFn;
00276   io->addWaitingSocketsFn=f;
00277 
00278   return of;
00279 }
00280 
00281 
00282 
00283 GWEN_IO_LAYER_LISTEN_FN GWEN_Io_Layer_SetListenFn(GWEN_IO_LAYER *io, GWEN_IO_LAYER_LISTEN_FN f) {
00284   GWEN_IO_LAYER_LISTEN_FN of;
00285 
00286   assert(io);
00287   assert(io->refCount);
00288 
00289   of=io->listenFn;
00290   io->listenFn=f;
00291 
00292   return of;
00293 }
00294 
00295 
00296 
00297 int GWEN_Io_Layer_WorkOnRequests(GWEN_IO_LAYER *io) {
00298   assert(io);
00299   assert(io->refCount);
00300 
00301   if (io->workOnRequestsFn)
00302     return io->workOnRequestsFn(io);
00303   else
00304     return GWEN_Io_Layer_WorkResultError;
00305 }
00306 
00307 
00308 
00309 int GWEN_Io_Layer_AddRequest(GWEN_IO_LAYER *io, GWEN_IO_REQUEST *r) {
00310   assert(io);
00311   assert(io->refCount);
00312 
00313   if (io->addRequestFn) {
00314     /* preset some vars */
00315     GWEN_Io_Request_SetStatus(r, GWEN_Io_Request_StatusEnqueued);
00316     GWEN_Io_Request_SetResultCode(r, 0);
00317     GWEN_Io_Request_SetBufferPos(r, 0);
00318     GWEN_Io_Request_SetIoLayer(r, io);
00319     return io->addRequestFn(io, r);
00320   }
00321   else
00322     return GWEN_ERROR_NOT_IMPLEMENTED;
00323 }
00324 
00325 
00326 
00327 int GWEN_Io_Layer_DelRequest(GWEN_IO_LAYER *io, GWEN_IO_REQUEST *r) {
00328   assert(io);
00329   assert(io->refCount);
00330 
00331   GWEN_Io_Request_SetIoLayer(r, NULL);
00332   if (io->delRequestFn)
00333     return io->delRequestFn(io, r);
00334   else
00335     return GWEN_ERROR_NOT_IMPLEMENTED;
00336 }
00337 
00338 
00339 
00340 int GWEN_Io_Layer_HasWaitingRequests(GWEN_IO_LAYER *io) {
00341   assert(io);
00342   assert(io->refCount);
00343 
00344   if (io->hasWaitingRequestsFn)
00345     return io->hasWaitingRequestsFn(io);
00346   else
00347     return GWEN_ERROR_NOT_IMPLEMENTED;
00348 }
00349 
00350 
00351 
00352 int GWEN_Io_Layer_AddWaitingSockets(GWEN_IO_LAYER *io,
00353                                     GWEN_SOCKET_LIST2 *readSockets,
00354                                     GWEN_SOCKET_LIST2 *writeSockets) {
00355   assert(io);
00356   assert(io->refCount);
00357 
00358   if (io->addWaitingSocketsFn)
00359     return io->addWaitingSocketsFn(io, readSockets, writeSockets);
00360   else {
00361     if (io->baseLayer)
00362       return GWEN_Io_Layer_AddWaitingSockets(io->baseLayer, readSockets, writeSockets);
00363     else
00364       return 0;
00365   }
00366 }
00367 
00368 
00369 
00370 int GWEN_Io_Layer_Listen(GWEN_IO_LAYER *io) {
00371   assert(io);
00372   assert(io->refCount);
00373 
00374   if (io->listenFn)
00375     return io->listenFn(io);
00376   else {
00377     GWEN_Io_Layer_SetStatus(io, GWEN_Io_Layer_StatusListening);
00378   }
00379 
00380   return 0;
00381 }
00382 
00383 
00384 
00385 int GWEN_Io_Layer__WaitForRequest(GWEN_IO_LAYER *io, GWEN_IO_REQUEST *r, int msecs,
00386                                   int deleteRequest) {
00387   int rv;
00388   GWEN_IO_REQUEST_STATUS st;
00389   GWEN_IO_REQUEST_TYPE t;
00390 
00391   t=GWEN_Io_Request_GetType(r);
00392 
00393   /* add request */
00394   rv=GWEN_Io_Layer_AddRequest(io, r);
00395   if (rv) {
00396     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00397     if (deleteRequest)
00398       GWEN_Io_Request_free(r);
00399     return rv;
00400   }
00401 
00402   /* wait for request to finish */
00403   rv=GWEN_Io_Manager_WaitForRequest(r, msecs);
00404   st=GWEN_Io_Request_GetStatus(r);
00405   if (rv) {
00406     DBG_INFO(GWEN_LOGDOMAIN, "here (%d, status=%d)", rv, st);
00407     if (st==GWEN_Io_Request_StatusEnqueued)
00408       GWEN_Io_Layer_DelRequest(io, r);
00409     if (deleteRequest)
00410       GWEN_Io_Request_free(r);
00411     return rv;
00412   }
00413 
00414   /* if not finished, report an error */
00415   if (st!=GWEN_Io_Request_StatusFinished) {
00416     DBG_INFO(GWEN_LOGDOMAIN, "Bad status of io request (%d)", GWEN_Io_Request_GetStatus(r));
00417     if (st==GWEN_Io_Request_StatusEnqueued)
00418       GWEN_Io_Layer_DelRequest(io, r);
00419     if (deleteRequest)
00420       GWEN_Io_Request_free(r);
00421     return rv;
00422   }
00423 
00424   /* check result code */
00425   rv=GWEN_Io_Request_GetResultCode(r);
00426   if (rv) {
00427     if (rv==GWEN_ERROR_EOF && t==GWEN_Io_Request_TypeRead) {
00428       rv=GWEN_Io_Request_GetBufferPos(r);
00429       if (rv==0) {
00430         /* only report EOF error if nothing could be read here */
00431         DBG_INFO(GWEN_LOGDOMAIN, "EOF, nothing read");
00432         if (deleteRequest)
00433           GWEN_Io_Request_free(r);
00434         return GWEN_ERROR_EOF;
00435       }
00436       /* otherwise use the standard handling below */
00437     }
00438     else {
00439       DBG_INFO(GWEN_LOGDOMAIN, "Result of IO request is an error (%d)", rv);
00440       if (deleteRequest)
00441         GWEN_Io_Request_free(r);
00442       return rv;
00443     }
00444   }
00445 
00446   /* return bufferpos, it is 0 for most non-read/write requests and holds the number of transfered bytes otherwise */
00447   rv=GWEN_Io_Request_GetBufferPos(r);
00448 
00449   if (deleteRequest)
00450     GWEN_Io_Request_free(r);
00451   return rv;
00452 }
00453 
00454 
00455 
00456 int GWEN_Io_Layer_Connect(GWEN_IO_LAYER *io,
00457                           uint32_t flags,
00458                           uint32_t guiid, int msecs) {
00459   GWEN_IO_REQUEST *r;
00460 
00461   /* create request */
00462   r=GWEN_Io_Request_new(GWEN_Io_Request_TypeConnect, NULL, 0, NULL, NULL, guiid);
00463   assert(r);
00464   GWEN_Io_Request_SetFlags(r, flags);
00465 
00466   return GWEN_Io_Layer__WaitForRequest(io, r, msecs, 1);
00467 }
00468 
00469 
00470 
00471 int GWEN_Io_Layer_ConnectRecursively(GWEN_IO_LAYER *io,
00472                                      GWEN_IO_LAYER *stopAtLayer,
00473                                      uint32_t flags,
00474                                      uint32_t guiid, int msecs) {
00475   assert(io);
00476   assert(io->refCount);
00477 
00478   if (io==stopAtLayer)
00479     /* caller wanted to stop here */
00480     return 0;
00481 
00482   /* first connect all base layers */
00483   if (io->baseLayer) {
00484     int rv;
00485 
00486     rv=GWEN_Io_Layer_ConnectRecursively(io->baseLayer, stopAtLayer, flags, guiid, msecs);
00487     if (rv)
00488       return rv;
00489   }
00490 
00491   /* then connect this layer, if it not already is */
00492   if (io->status!=GWEN_Io_Layer_StatusConnected)
00493     return GWEN_Io_Layer_Connect(io, flags, guiid, msecs);
00494   return 0;
00495 }
00496 
00497 
00498 
00499 int GWEN_Io_Layer_ListenRecursively(GWEN_IO_LAYER *io, GWEN_IO_LAYER *stopAtLayer) {
00500   assert(io);
00501   assert(io->refCount);
00502 
00503   if (io==stopAtLayer)
00504     /* caller wanted to stop here */
00505     return 0;
00506 
00507   /* first connect all base layers */
00508   if (io->baseLayer) {
00509     int rv;
00510 
00511     rv=GWEN_Io_Layer_ListenRecursively(io->baseLayer, stopAtLayer);
00512     if (rv)
00513       return rv;
00514   }
00515 
00516   /* then connect this layer, if it not already is */
00517   if (io->status!=GWEN_Io_Layer_StatusListening) {
00518     return GWEN_Io_Layer_Listen(io);
00519   }
00520   return 0;
00521 }
00522 
00523 
00524 
00525 int GWEN_Io_Layer_Disconnect(GWEN_IO_LAYER *io,
00526                              uint32_t flags,
00527                              uint32_t guiid, int msecs) {
00528   GWEN_IO_REQUEST *r;
00529 
00530   assert(io);
00531   assert(io->refCount);
00532 
00533   /* create request */
00534   r=GWEN_Io_Request_new(GWEN_Io_Request_TypeDisconnect, NULL, 0, NULL, NULL, guiid);
00535   assert(r);
00536   GWEN_Io_Request_SetFlags(r, flags);
00537 
00538   return GWEN_Io_Layer__WaitForRequest(io, r, msecs, 1);
00539 }
00540 
00541 
00542 
00543 int GWEN_Io_Layer__DisconnectRecursively(GWEN_IO_LAYER *io,
00544                                          GWEN_IO_LAYER *stopAtLayer,
00545                                          uint32_t flags,
00546                                          uint32_t guiid, int msecs) {
00547   int firstError=0;
00548 
00549   assert(io);
00550   assert(io->refCount);
00551 
00552   if (io==stopAtLayer)
00553     /* caller wanted to stop here */
00554     return 0;
00555 
00556   /* disconnect this layer, if it not already is */
00557   if (io->status!=GWEN_Io_Layer_StatusDisconnected)
00558     firstError=GWEN_Io_Layer_Disconnect(io, flags, guiid, msecs);
00559 
00560   /* first connect all base layers */
00561   if (io->baseLayer) {
00562     int rv;
00563 
00564     rv=GWEN_Io_Layer__DisconnectRecursively(io->baseLayer, stopAtLayer, flags, guiid, msecs);
00565     if (rv && firstError==0)
00566       firstError=rv;
00567   }
00568 
00569   return firstError;
00570 }
00571 
00572 
00573 
00574 int GWEN_Io_Layer_DisconnectRecursively(GWEN_IO_LAYER *io,
00575                                         GWEN_IO_LAYER *stopAtLayer,
00576                                         uint32_t flags,
00577                                         uint32_t guiid, int msecs) {
00578   int rv;
00579 
00580   if (!(flags & GWEN_IO_REQUEST_FLAGS_FORCE)) {
00581     rv=GWEN_Io_Layer_FlushRecursively(io, guiid, msecs);
00582     if (rv<0) {
00583       DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00584       /* return rv; */
00585     }
00586   }
00587 
00588   rv=GWEN_Io_Layer__DisconnectRecursively(io, stopAtLayer, flags, guiid, msecs);
00589   if (rv<0) {
00590     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00591     return rv;
00592   }
00593 
00594   return 0;
00595 }
00596 
00597 
00598 
00599 int GWEN_Io_Layer_ReadBytes(GWEN_IO_LAYER *io,
00600                             uint8_t *buffer,
00601                             uint32_t size,
00602                             uint32_t flags,
00603                             uint32_t guiid, int msecs) {
00604   GWEN_IO_REQUEST *r;
00605   int rv;
00606 
00607   assert(io);
00608   assert(io->refCount);
00609 
00610   /* create request */
00611   r=GWEN_Io_Request_new(GWEN_Io_Request_TypeRead, buffer, size, NULL, NULL, guiid);
00612   assert(r);
00613   GWEN_Io_Request_SetFlags(r, flags);
00614 
00615   rv=GWEN_Io_Layer__WaitForRequest(io, r, msecs, 1);
00616   if (rv<0) {
00617     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00618   }
00619   return rv;
00620 }
00621 
00622 
00623 
00624 int GWEN_Io_Layer_ReadPacket(GWEN_IO_LAYER *io,
00625                              uint8_t *buffer,
00626                              uint32_t size,
00627                              uint32_t flags,
00628                              uint32_t guiid, int msecs) {
00629   GWEN_IO_REQUEST *r;
00630   int rv;
00631   int loop;
00632   uint32_t bytesRead=0;
00633 
00634   assert(io);
00635   assert(io->refCount);
00636 
00637   for (loop=0;;loop++) {
00638     uint32_t rflags;
00639 
00640     /* create request */
00641     r=GWEN_Io_Request_new(GWEN_Io_Request_TypeRead, buffer, size, NULL, NULL, guiid);
00642     assert(r);
00643     GWEN_Io_Request_SetFlags(r, flags);
00644     if (loop==0)
00645       GWEN_Io_Request_AddFlags(r, GWEN_IO_REQUEST_FLAGS_PACKETBEGIN);
00646 
00647     rv=GWEN_Io_Layer__WaitForRequest(io, r, msecs, 0);
00648     rflags=GWEN_Io_Request_GetFlags(r);
00649     GWEN_Io_Request_free(r);
00650     if (rv<0) {
00651       DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00652       return rv;
00653     }
00654     bytesRead+=rv;
00655     if (rflags & GWEN_IO_REQUEST_FLAGS_PACKETEND) {
00656       return bytesRead;
00657     }
00658     else if ((int)size<=rv) {
00659       DBG_ERROR(GWEN_LOGDOMAIN, "Buffer overrun after reading %d bytes", bytesRead);
00660       return GWEN_ERROR_BUFFER_OVERFLOW;
00661     }
00662     size-=rv;
00663     buffer+=rv;
00664   }
00665 }
00666 
00667 
00668 
00669 int GWEN_Io_Layer_ReadPacketToBuffer(GWEN_IO_LAYER *io,
00670                                      GWEN_BUFFER *buf,
00671                                      uint32_t flags,
00672                                      uint32_t guiid, int msecs) {
00673   GWEN_IO_REQUEST *r;
00674   int rv;
00675   int loop;
00676   uint32_t bytesRead=0;
00677 
00678   assert(io);
00679   assert(io->refCount);
00680 
00681   for (loop=0;;loop++) {
00682     uint32_t rflags;
00683     uint8_t *p;
00684     uint32_t bRead;
00685 
00686     GWEN_Buffer_AllocRoom(buf, 512);
00687     p=(uint8_t*)GWEN_Buffer_GetPosPointer(buf);
00688     /* create request */
00689     r=GWEN_Io_Request_new(GWEN_Io_Request_TypeRead, p, 512, NULL, NULL, guiid);
00690     assert(r);
00691     GWEN_Io_Request_SetFlags(r, flags);
00692     if (loop==0)
00693       GWEN_Io_Request_AddFlags(r, GWEN_IO_REQUEST_FLAGS_PACKETBEGIN);
00694 
00695     rv=GWEN_Io_Layer__WaitForRequest(io, r, msecs, 0);
00696     rflags=GWEN_Io_Request_GetFlags(r);
00697     bRead=GWEN_Io_Request_GetBufferPos(r);
00698     bytesRead+=bRead;
00699     GWEN_Buffer_IncrementPos(buf, bRead);
00700     GWEN_Buffer_AdjustUsedBytes(buf);
00701     GWEN_Io_Request_free(r);
00702     if (rv<0) {
00703       if (rv==GWEN_ERROR_EOF && bytesRead) {
00704         DBG_INFO(GWEN_LOGDOMAIN,
00705                  "EOF met with %d bytes read, assuming packet end",
00706                  bytesRead);
00707         return bytesRead;
00708       }
00709       else {
00710         DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00711         return rv;
00712       }
00713     }
00714     if (rflags & GWEN_IO_REQUEST_FLAGS_PACKETEND) {
00715       return bytesRead;
00716     }
00717   }
00718 }
00719 
00720 
00721 
00722 int GWEN_Io_Layer_WriteBytes(GWEN_IO_LAYER *io,
00723                              const uint8_t *buffer,
00724                              uint32_t size,
00725                              uint32_t flags,
00726                              uint32_t guiid, int msecs) {
00727   GWEN_IO_REQUEST *r;
00728   int rv;
00729 
00730   assert(io);
00731   assert(io->refCount);
00732 
00733   /* create request */
00734   r=GWEN_Io_Request_new(GWEN_Io_Request_TypeWrite, (uint8_t*) buffer, size, NULL, NULL, guiid);
00735   assert(r);
00736   GWEN_Io_Request_SetFlags(r, flags);
00737 
00738   rv=GWEN_Io_Layer__WaitForRequest(io, r, msecs, 1);
00739   if (rv<0) {
00740     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00741   }
00742 
00743   return rv;
00744 }
00745 
00746 
00747 
00748 int GWEN_Io_Layer_WriteString(GWEN_IO_LAYER *io,
00749                               const char *buffer,
00750                               uint32_t flags,
00751                               uint32_t guiid, int msecs) {
00752   GWEN_IO_REQUEST *r;
00753   uint32_t size=0;
00754   int rv;
00755 
00756   assert(io);
00757   assert(io->refCount);
00758 
00759   /* create request */
00760   if (buffer)
00761     size=strlen(buffer);
00762   r=GWEN_Io_Request_new(GWEN_Io_Request_TypeWrite, (uint8_t*) buffer, size, NULL, NULL, guiid);
00763   assert(r);
00764   GWEN_Io_Request_SetFlags(r, flags);
00765 
00766   rv=GWEN_Io_Layer__WaitForRequest(io, r, msecs, 1);
00767   if (rv<0) {
00768     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00769   }
00770 
00771   return rv;
00772 }
00773 
00774 
00775 
00776 int GWEN_Io_Layer_WriteChar(GWEN_IO_LAYER *io,
00777                             char c,
00778                             uint32_t flags,
00779                             uint32_t guiid, int msecs) {
00780   GWEN_IO_REQUEST *r;
00781   int rv;
00782 
00783   assert(io);
00784   assert(io->refCount);
00785 
00786   /* create request */
00787   r=GWEN_Io_Request_new(GWEN_Io_Request_TypeWrite, (uint8_t*) &c, 1, NULL, NULL, guiid);
00788   assert(r);
00789   GWEN_Io_Request_SetFlags(r, flags);
00790 
00791   rv=GWEN_Io_Layer__WaitForRequest(io, r, msecs, 1);
00792   if (rv<0) {
00793     DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00794   }
00795 
00796   return rv;
00797 }
00798 
00799 
00800 
00801 int GWEN_Io_Layer_ReadToBufferUntilEof(GWEN_IO_LAYER *io,
00802                                        GWEN_BUFFER *buf,
00803                                        uint32_t guiid, int msecs) {
00804   int total=0;
00805 
00806   assert(io);
00807   assert(io->refCount);
00808 
00809   for(;;) {
00810     int rv;
00811     uint8_t buffer[256];
00812 
00813     rv=GWEN_Io_Layer_ReadBytes(io, buffer, sizeof(buffer), 0, guiid, msecs);
00814     if (rv<0) {
00815       if (rv==GWEN_ERROR_EOF)
00816         return total;
00817       DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00818       return rv;
00819     }
00820     else if (rv==0) {
00821       return total;
00822     }
00823     else {
00824       GWEN_Buffer_AppendBytes(buf, (const char*)buffer, rv);
00825       total+=rv;
00826     }
00827   }
00828 }
00829 
00830 
00831 
00832 int GWEN_Io_Layer_FlushRecursively(GWEN_IO_LAYER *io, uint32_t guiid, int msecs) {
00833   GWEN_IO_LAYER *currIo;
00834 
00835   currIo=io;
00836   while(currIo) {
00837     int rv;
00838 
00839     rv=GWEN_Io_Layer_WriteString(currIo, "",
00840                                  GWEN_IO_REQUEST_FLAGS_FLUSH,
00841                                  guiid,
00842                                  msecs);
00843     if (rv<0) {
00844       DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
00845       return rv;
00846     }
00847     currIo=currIo->baseLayer;
00848   }
00849 
00850   return 0;
00851 }
00852 
00853 
00854 
00855 
00856 
00857 
00858 
00859 

Generated on Thu Aug 20 13:54:38 2009 for gwenhywfar by  doxygen 1.5.9