bio_buffer.c

Go to the documentation of this file.
00001 /***************************************************************************
00002  $RCSfile$
00003  -------------------
00004  cvs         : $Id$
00005  begin       : Fri Feb 07 2003
00006  copyright   : (C) 2003 by Martin Preuss
00007  email       : martin@libchipcard.de
00008 
00009  ***************************************************************************
00010  *                                                                         *
00011  *   This library is free software; you can redistribute it and/or         *
00012  *   modify it under the terms of the GNU Lesser General Public            *
00013  *   License as published by the Free Software Foundation; either          *
00014  *   version 2.1 of the License, or (at your option) any later version.    *
00015  *                                                                         *
00016  *   This library is distributed in the hope that it will be useful,       *
00017  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
00018  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
00019  *   Lesser General Public License for more details.                       *
00020  *                                                                         *
00021  *   You should have received a copy of the GNU Lesser General Public      *
00022  *   License along with this library; if not, write to the Free Software   *
00023  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,                 *
00024  *   MA  02111-1307  USA                                                   *
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                                  GWEN_UNUSED 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                                   GWEN_UNUSED 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(GWEN_UNUSED 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 

Generated on Sat Jan 2 09:32:35 2010 for gwenhywfar by  doxygen 1.6.1