00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifdef HAVE_CONFIG_H
00030 # include <config.h>
00031 #endif
00032
00033 #define DISABLE_DEBUGLOG
00034
00035
00036 #include "bio_buffer_p.h"
00037 #include <gwenhywfar/misc.h>
00038 #include <gwenhywfar/text.h>
00039 #include <stdlib.h>
00040 #ifdef HAVE_UNISTD_H
00041 # include <unistd.h>
00042 #endif
00043 #include <string.h>
00044 #include <errno.h>
00045
00046 #include <gwenhywfar/debug.h>
00047
00048
00049 GWEN_INHERIT(GWEN_BUFFEREDIO, GWEN_BUFFEREDIO_BUFFER)
00050
00051
00052 GWEN_BUFFEREDIO_BUFFER *GWEN_BufferedIO_Buffer_Table__new() {
00053 GWEN_BUFFEREDIO_BUFFER *bft;
00054
00055 GWEN_NEW_OBJECT(GWEN_BUFFEREDIO_BUFFER, bft);
00056 bft->closed=0;
00057 return bft;
00058 }
00059
00060
00061
00062 void GWEN_BufferedIO_Buffer_Table__free(GWEN_BUFFEREDIO_BUFFER *bft) {
00063 if (bft) {
00064 if (bft->own)
00065 GWEN_Buffer_free(bft->buffer);
00066 GWEN_FREE_OBJECT(bft);
00067 }
00068 }
00069
00070
00071
00072 int GWEN_BufferedIO_Buffer__Read(GWEN_BUFFEREDIO *dm,
00073 char *buffer,
00074 int *size,
00075 int timeout){
00076 GWEN_BUFFEREDIO_BUFFER *bft;
00077 unsigned int readSize;
00078
00079 assert(dm);
00080 assert(buffer);
00081 assert(size);
00082 bft=GWEN_INHERIT_GETDATA(GWEN_BUFFEREDIO, GWEN_BUFFEREDIO_BUFFER, dm);
00083 assert(bft);
00084 assert(bft->buffer);
00085
00086 if (bft->closed) {
00087 DBG_INFO(GWEN_LOGDOMAIN, "Channel closed");
00088 return GWEN_ERROR_READ;
00089 }
00090
00091 if (*size<1) {
00092 DBG_WARN(GWEN_LOGDOMAIN, "Nothing to read");
00093 *size=0;
00094 return 0;
00095 }
00096
00097 readSize=*size;
00098 if (GWEN_Buffer_ReadBytes(bft->buffer, buffer, &readSize)) {
00099 DBG_ERROR(GWEN_LOGDOMAIN, "Error reading from buffer");
00100 return GWEN_ERROR_READ;
00101 }
00102 *size=readSize;
00103 DBG_VERBOUS(GWEN_LOGDOMAIN, "Reading ok (%d bytes)", *size);
00104 return 0;
00105 }
00106
00107
00108
00109 int GWEN_BufferedIO_Buffer__Write(GWEN_BUFFEREDIO *dm,
00110 const char *buffer,
00111 int *size,
00112 int timeout){
00113 GWEN_BUFFEREDIO_BUFFER *bft;
00114
00115 assert(dm);
00116 assert(buffer);
00117 assert(size);
00118 bft=GWEN_INHERIT_GETDATA(GWEN_BUFFEREDIO, GWEN_BUFFEREDIO_BUFFER, dm);
00119 assert(bft);
00120 assert(bft->buffer);
00121
00122 if (bft->closed) {
00123 DBG_INFO(GWEN_LOGDOMAIN, "Channel closed");
00124 return GWEN_ERROR_WRITE;
00125 }
00126
00127 if (*size<1) {
00128 DBG_WARN(GWEN_LOGDOMAIN, "Nothing to write");
00129 *size=0;
00130 return 0;
00131 }
00132
00133 if (GWEN_Buffer_AppendBytes(bft->buffer, buffer, *size)) {
00134 DBG_INFO(GWEN_LOGDOMAIN, "called from here");
00135 return GWEN_ERROR_WRITE;
00136 }
00137
00138 DBG_VERBOUS(GWEN_LOGDOMAIN, "Writing ok");
00139 return 0;
00140 }
00141
00142
00143
00144 int GWEN_BufferedIO_Buffer__Close(GWEN_BUFFEREDIO *dm){
00145 GWEN_BUFFEREDIO_BUFFER *bft;
00146
00147 assert(dm);
00148 bft=GWEN_INHERIT_GETDATA(GWEN_BUFFEREDIO, GWEN_BUFFEREDIO_BUFFER, dm);
00149 assert(bft);
00150 assert(bft->buffer);
00151 DBG_DEBUG(GWEN_LOGDOMAIN, "Closing socket");
00152
00153 if (bft->closed) {
00154 DBG_DEBUG(GWEN_LOGDOMAIN, "Channel already closed");
00155 }
00156 else
00157 bft->closed=1;
00158 return 0;
00159 }
00160
00161
00162
00163 void GWENHYWFAR_CB GWEN_BufferedIO_Buffer_FreeData(void *bp, void *p) {
00164 GWEN_BUFFEREDIO_BUFFER *bft;
00165
00166 bft=(GWEN_BUFFEREDIO_BUFFER*)p;
00167 GWEN_BufferedIO_Buffer_Table__free(bft);
00168 }
00169
00170
00171
00172 GWEN_BUFFEREDIO *GWEN_BufferedIO_Buffer2_new(GWEN_BUFFER *buffer, int take){
00173 GWEN_BUFFEREDIO *bt;
00174 GWEN_BUFFEREDIO_BUFFER *bft;
00175
00176 assert(buffer);
00177 bt=GWEN_BufferedIO_new();
00178 bft=GWEN_BufferedIO_Buffer_Table__new();
00179 bft->buffer=buffer;
00180 bft->own=take;
00181
00182 GWEN_INHERIT_SETDATA(GWEN_BUFFEREDIO, GWEN_BUFFEREDIO_BUFFER,
00183 bt, bft,
00184 GWEN_BufferedIO_Buffer_FreeData);
00185 GWEN_BufferedIO_SetReadFn(bt, GWEN_BufferedIO_Buffer__Read);
00186 GWEN_BufferedIO_SetWriteFn(bt, GWEN_BufferedIO_Buffer__Write);
00187 GWEN_BufferedIO_SetCloseFn(bt, GWEN_BufferedIO_Buffer__Close);
00188 GWEN_BufferedIO_SetTimeout(bt, 0);
00189
00190 return bt;
00191 }
00192
00193
00194
00195 GWEN_BUFFEREDIO *GWEN_BufferedIO_Buffer_new(GWEN_BUFFER *buffer){
00196 return GWEN_BufferedIO_Buffer2_new(buffer, 1);
00197 }
00198
00199
00200
00201 GWEN_BUFFEREDIO *GWEN_BufferedIO_Buffer_fromString(const char *s,
00202 int len){
00203 GWEN_BUFFER *dbuf;
00204
00205 if (len==0)
00206 len=strlen(s);
00207 dbuf=GWEN_Buffer_new(0, len, 0, 1);
00208 GWEN_Buffer_AppendBytes(dbuf, s, len);
00209 GWEN_Buffer_Rewind(dbuf);
00210 return GWEN_BufferedIO_Buffer2_new(dbuf, 1);
00211 }
00212
00213
00214
00215