00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
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
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
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
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
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
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
00431 DBG_INFO(GWEN_LOGDOMAIN, "EOF, nothing read");
00432 if (deleteRequest)
00433 GWEN_Io_Request_free(r);
00434 return GWEN_ERROR_EOF;
00435 }
00436
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
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
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
00480 return 0;
00481
00482
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
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
00505 return 0;
00506
00507
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
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
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
00554 return 0;
00555
00556
00557 if (io->status!=GWEN_Io_Layer_StatusDisconnected)
00558 firstError=GWEN_Io_Layer_Disconnect(io, flags, guiid, msecs);
00559
00560
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
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
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
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 (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
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
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
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
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