gwenhywfar  4.8.0beta
syncio.c
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Tue Apr 27 2010
3  copyright : (C) 2010 by Martin Preuss
4  email : martin@libchipcard.de
5 
6  ***************************************************************************
7  * *
8  * This library is free software; you can redistribute it and/or *
9  * modify it under the terms of the GNU Lesser General Public *
10  * License as published by the Free Software Foundation; either *
11  * version 2.1 of the License, or (at your option) any later version. *
12  * *
13  * This library is distributed in the hope that it will be useful, *
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
16  * Lesser General Public License for more details. *
17  * *
18  * You should have received a copy of the GNU Lesser General Public *
19  * License along with this library; if not, write to the Free Software *
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21  * MA 02111-1307 USA *
22  * *
23  ***************************************************************************/
24 
25 #ifdef HAVE_CONFIG_H
26 # include <config.h>
27 #endif
28 
29 #define DISABLE_DEBUGLOG
30 
31 
32 #include "syncio_p.h"
33 #include "syncio_file.h"
34 #include "syncio_buffered.h"
35 
36 #include <gwenhywfar/misc.h>
37 #include <gwenhywfar/debug.h>
38 
39 #include <assert.h>
40 #include <stdlib.h>
41 #include <string.h>
42 
43 
44 
46 GWEN_LIST_FUNCTIONS(GWEN_SYNCIO, GWEN_SyncIo)
47 
48 
49 
50 
51 GWEN_SYNCIO *GWEN_SyncIo_new(const char *typeName, GWEN_SYNCIO *baseIo) {
52  GWEN_SYNCIO *sio;
53 
54  assert(typeName);
55  GWEN_NEW_OBJECT(GWEN_SYNCIO, sio);
56  sio->refCount=1;
57  GWEN_INHERIT_INIT(GWEN_SYNCIO, sio);
58  GWEN_LIST_INIT(GWEN_SYNCIO, sio);
59 
60  sio->typeName=strdup(typeName);
61  sio->baseIo=baseIo;
62 
63  return sio;
64 }
65 
66 
67 
69  assert(sio);
70  assert(sio->refCount);
71  sio->refCount++;
72 }
73 
74 
75 
77  if (sio) {
78  assert(sio->refCount);
79  if (sio->refCount==1) {
82  GWEN_SyncIo_free(sio->baseIo);
83  free(sio->typeName);
84  sio->refCount=0;
85  GWEN_FREE_OBJECT(sio);
86  }
87  else
88  sio->refCount--;
89  }
90 }
91 
92 
93 
95  assert(sio);
96  assert(sio->refCount);
97  if (sio->connectFn)
98  return sio->connectFn(sio);
99  else
100  return 0;
101 }
102 
103 
104 
106  assert(sio);
107  assert(sio->refCount);
108  if (sio->disconnectFn)
109  return sio->disconnectFn(sio);
110  else
111  return 0;
112 }
113 
114 
115 
117  assert(sio);
118  assert(sio->refCount);
119  if (sio->flushFn)
120  return sio->flushFn(sio);
121  else
122  return 0;
123 }
124 
125 
126 
128  uint8_t *buffer,
129  uint32_t size) {
130  assert(sio);
131  assert(sio->refCount);
132  if (sio->readFn)
133  return sio->readFn(sio, buffer, size);
134  else
135  return GWEN_ERROR_EOF;
136 }
137 
138 
139 
141  const uint8_t *buffer,
142  uint32_t size) {
143  assert(sio);
144  assert(sio->refCount);
145  if (sio->writeFn)
146  return sio->writeFn(sio, buffer, size);
147  else
148  return GWEN_ERROR_BROKEN_PIPE;
149 }
150 
151 
152 
153 uint32_t GWEN_SyncIo_GetFlags(const GWEN_SYNCIO *sio) {
154  assert(sio);
155  assert(sio->refCount);
156  return sio->flags;
157 }
158 
159 
160 
161 void GWEN_SyncIo_SetFlags(GWEN_SYNCIO *sio, uint32_t fl) {
162  assert(sio);
163  assert(sio->refCount);
164  sio->flags=fl;
165 }
166 
167 
168 
169 void GWEN_SyncIo_AddFlags(GWEN_SYNCIO *sio, uint32_t fl) {
170  assert(sio);
171  assert(sio->refCount);
172  sio->flags|=fl;
173 }
174 
175 
176 
177 void GWEN_SyncIo_SubFlags(GWEN_SYNCIO *sio, uint32_t fl) {
178  assert(sio);
179  assert(sio->refCount);
180  sio->flags&=~fl;
181 }
182 
183 
184 
186  assert(sio);
187  assert(sio->refCount);
188  return sio->status;
189 }
190 
191 
192 
194  assert(sio);
195  assert(sio->refCount);
196  sio->status=st;
197 }
198 
199 
200 
201 const char *GWEN_SyncIo_GetTypeName(const GWEN_SYNCIO *sio) {
202  assert(sio);
203  assert(sio->refCount);
204  return sio->typeName;
205 }
206 
207 
208 
210  assert(sio);
211  assert(sio->refCount);
212  return sio->baseIo;
213 }
214 
215 
216 
217 GWEN_SYNCIO *GWEN_SyncIo_GetBaseIoByTypeName(const GWEN_SYNCIO *sio, const char *typeName) {
218  GWEN_SYNCIO *baseIo;
219 
220  assert(sio);
221  assert(sio->refCount);
222 
223  baseIo=sio->baseIo;
224  while(baseIo) {
225  if (baseIo->typeName && strcasecmp(baseIo->typeName, typeName)==0)
226  return baseIo;
227  baseIo=baseIo->baseIo;
228  }
229 
230  return NULL;
231 }
232 
233 
234 
237 
238  assert(sio);
239  assert(sio->refCount);
240  of=sio->connectFn;
241  sio->connectFn=fn;
242  return of;
243 }
244 
245 
246 
249 
250  assert(sio);
251  assert(sio->refCount);
252  of=sio->disconnectFn;
253  sio->disconnectFn=fn;
254  return of;
255 }
256 
257 
258 
261 
262  assert(sio);
263  assert(sio->refCount);
264  of=sio->flushFn;
265  sio->flushFn=fn;
266  return of;
267 }
268 
269 
270 
273 
274  assert(sio);
275  assert(sio->refCount);
276  of=sio->readFn;
277  sio->readFn=fn;
278  return of;
279 }
280 
281 
282 
285 
286  assert(sio);
287  assert(sio->refCount);
288  of=sio->writeFn;
289  sio->writeFn=fn;
290  return of;
291 }
292 
293 
294 
296  const uint8_t *buffer,
297  uint32_t size) {
298  if (size==0) {
299  int rv;
300 
301  do {
302  rv=GWEN_SyncIo_Write(sio, buffer, size);
303  } while (rv==GWEN_ERROR_INTERRUPTED);
304  if (rv<0) {
305  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
306  return rv;
307  }
308  return 0;
309  }
310  else {
311  uint32_t todo;
312 
313  todo=size;
314  while(todo) {
315  int rv;
316 
317  do {
318  rv=GWEN_SyncIo_Write(sio, buffer, todo);
319  } while (rv==GWEN_ERROR_INTERRUPTED);
320 
321  if (rv<0) {
322  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
323  return rv;
324  }
325  todo-=rv;
326  buffer+=rv;
327  }
328 
329  return size;
330  }
331 }
332 
333 
334 
336  uint8_t *buffer,
337  uint32_t size) {
338  uint32_t todo;
339 
340  todo=size;
341  while(todo) {
342  int rv;
343 
344  do {
345  rv=GWEN_SyncIo_Read(sio, buffer, todo);
346  } while (rv==GWEN_ERROR_INTERRUPTED);
347 
348  if (rv<0) {
349  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
350  return rv;
351  }
352  else if (rv==0) {
353  DBG_ERROR(GWEN_LOGDOMAIN, "EOF met");
354  return GWEN_ERROR_EOF;
355  }
356  todo-=rv;
357  buffer+=rv;
358  }
359 
360  return size;
361 }
362 
363 
364 
365 int GWEN_SyncIo_WriteString(GWEN_SYNCIO *sio, const char *s) {
366  int rv;
367 
368  rv=GWEN_SyncIo_WriteForced(sio, (const uint8_t*) s, s?strlen(s):0);
369  if (rv<0) {
370  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
371  return rv;
372  }
373 
374  return 0;
375 }
376 
377 
378 
379 int GWEN_SyncIo_WriteLine(GWEN_SYNCIO *sio, const char *s) {
380  int rv;
381 
382  rv=GWEN_SyncIo_WriteString(sio, s);
383  if (rv<0) {
384  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
385  return rv;
386  }
387 
389  rv=GWEN_SyncIo_WriteForced(sio, (const uint8_t*) "\r\n", 2);
390  else
391  rv=GWEN_SyncIo_WriteForced(sio, (const uint8_t*) "\n", 1);
392  if (rv<0) {
393  DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);
394  return rv;
395  }
396 
397  return 0;
398 }
399 
400 
401 
403  return GWEN_SyncIo_WriteForced(sio, (const uint8_t*) &s, 1);
404 }
405 
406 
407 
409  int maxLines,
410  GWEN_STRINGLIST *sl) {
411  GWEN_SYNCIO *sio;
412  GWEN_SYNCIO *baseSio;
413  int rv;
414 
415  /* open checksums from file */
418  sio=GWEN_SyncIo_Buffered_new(baseSio);
419 
420  rv=GWEN_SyncIo_Connect(sio);
421  if (rv<0) {
422  DBG_INFO(GWEN_LOGDOMAIN, "Could not open file [%s]", fname?fname:"<no filename>");
423  GWEN_SyncIo_free(sio);
424  return rv;
425  }
426 
427  /* read up to maxlines lines from file */
428  rv=GWEN_SyncIo_Buffered_ReadLinesToStringList(sio, maxLines, sl);
429  if (rv<0) {
430  DBG_INFO(GWEN_LOGDOMAIN, "Could not open file [%s]", fname?fname:"<no filename>");
432  GWEN_SyncIo_free(sio);
433  return rv;
434  }
435 
436  /* close file */
438  GWEN_SyncIo_free(sio);
439  return 0;
440 }
441 
442 
443