source: roaraudio/libroar/vio_dstr.c @ 1328:9c33a74ef1dc

Last change on this file since 1328:9c33a74ef1dc was 1328:9c33a74ef1dc, checked in by phi, 15 years ago

got vio dstr basicly working
File size: 13.8 KB
Line 
1//vio_dstr.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009
5 *
6 *  This file is part of libroar a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroar is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22 *
23 *  NOTE for everyone want's to change something and send patches:
24 *  read README and HACKING! There a addition information on
25 *  the license of this document you need to read before you send
26 *  any patches.
27 *
28 *  NOTE for uses of non-GPL (LGPL,...) software using libesd, libartsc
29 *  or libpulse*:
30 *  The libs libroaresd, libroararts and libroarpulse link this lib
31 *  and are therefore GPL. Because of this it may be illigal to use
32 *  them with any software that uses libesd, libartsc or libpulse*.
33 */
34
35#include "libroar.h"
36
37struct {
38 int    id;
39 char * name;
40 int    pdeftype[16];
41} _roar_vio_dstr_objs[] = {
42/*
43grep '^#define ROAR_VIO_DSTR_OBJT_' vio_dstr.h | cut -d' ' -f2 | while read objt; do name=`cut -d_ -f5,6,7,8,9,10 <<<$objt | tr A-Z a-z`; echo -e " {$objt,\t \"$name\","; echo "      {ROAR_VIO_DEF_TYPE_EOL}},"; done;
44*/
45 {ROAR_VIO_DSTR_OBJT_FILE,       "file",
46      {ROAR_VIO_DEF_TYPE_EOL}},
47 {ROAR_VIO_DSTR_OBJT_FH,         "fh",
48      {ROAR_VIO_DEF_TYPE_EOL}},
49 {ROAR_VIO_DSTR_OBJT_FD,         "fd",
50      {ROAR_VIO_DEF_TYPE_EOL}},
51 {ROAR_VIO_DSTR_OBJT_SOCKETFH,   "socketfh",
52      {ROAR_VIO_DEF_TYPE_EOL}},
53 {ROAR_VIO_DSTR_OBJT_PASS,       "pass",
54      {ROAR_VIO_DEF_TYPE_EOL}},
55 {ROAR_VIO_DSTR_OBJT_RE,         "re",
56      {ROAR_VIO_DEF_TYPE_EOL}},
57 {ROAR_VIO_DSTR_OBJT_EXEC,       "exec",
58      {ROAR_VIO_DEF_TYPE_EOL}},
59
60 {ROAR_VIO_DSTR_OBJT_SOCKET,     "socket",
61      {ROAR_VIO_DEF_TYPE_EOL}},
62 {ROAR_VIO_DSTR_OBJT_UNIX,       "unix",
63      {ROAR_VIO_DEF_TYPE_EOL}},
64 {ROAR_VIO_DSTR_OBJT_DECNET,     "decnet",
65      {ROAR_VIO_DEF_TYPE_EOL}},
66 {ROAR_VIO_DSTR_OBJT_TCP,        "tcp",
67      {ROAR_VIO_DEF_TYPE_EOL}},
68 {ROAR_VIO_DSTR_OBJT_UDP,        "udp",
69      {ROAR_VIO_DEF_TYPE_EOL}},
70 {ROAR_VIO_DSTR_OBJT_TCP6,       "tcp6",
71      {ROAR_VIO_DEF_TYPE_EOL}},
72 {ROAR_VIO_DSTR_OBJT_UDP6,       "udp6",
73      {ROAR_VIO_DEF_TYPE_EOL}},
74
75 {ROAR_VIO_DSTR_OBJT_SOCKS,      "socks",
76      {ROAR_VIO_DEF_TYPE_EOL}},
77 {ROAR_VIO_DSTR_OBJT_SOCKS4,     "socks4",
78      {ROAR_VIO_DEF_TYPE_EOL}},
79 {ROAR_VIO_DSTR_OBJT_SOCKS4A,    "socks4a",
80      {ROAR_VIO_DEF_TYPE_EOL}},
81 {ROAR_VIO_DSTR_OBJT_SOCKS4D,    "socks4d",
82      {ROAR_VIO_DEF_TYPE_EOL}},
83 {ROAR_VIO_DSTR_OBJT_SOCKS5,     "socks5",
84      {ROAR_VIO_DEF_TYPE_EOL}},
85 {ROAR_VIO_DSTR_OBJT_SSH,        "ssh",
86      {ROAR_VIO_DEF_TYPE_EOL}},
87
88 {ROAR_VIO_DSTR_OBJT_HTTP09,     "http09",
89      {ROAR_VIO_DEF_TYPE_EOL}},
90 {ROAR_VIO_DSTR_OBJT_HTTP10,     "http10",
91      {ROAR_VIO_DEF_TYPE_EOL}},
92 {ROAR_VIO_DSTR_OBJT_HTTP11,     "http11",
93      {ROAR_VIO_DEF_TYPE_EOL}},
94 {ROAR_VIO_DSTR_OBJT_HTTP,       "http",
95      {ROAR_VIO_DEF_TYPE_EOL}},
96 {ROAR_VIO_DSTR_OBJT_GOPHER,     "gopher",
97      {ROAR_VIO_DEF_TYPE_EOL}},
98
99 {ROAR_VIO_DSTR_OBJT_GZIP,       "gzip",
100      {ROAR_VIO_DEF_TYPE_EOL}},
101 {ROAR_VIO_DSTR_OBJT_BZIP2,      "bzip2",
102      {ROAR_VIO_DEF_TYPE_EOL}},
103
104 {ROAR_VIO_DSTR_OBJT_PGP,        "pgp",
105      {ROAR_VIO_DEF_TYPE_EOL}},
106 {ROAR_VIO_DSTR_OBJT_PGP_ENC,    "pgp_enc",
107      {ROAR_VIO_DEF_TYPE_EOL}},
108 {ROAR_VIO_DSTR_OBJT_PGP_STORE,  "pgp_store",
109      {ROAR_VIO_DEF_TYPE_EOL}},
110 {ROAR_VIO_DSTR_OBJT_SSL1,       "ssl1",
111      {ROAR_VIO_DEF_TYPE_EOL}},
112 {ROAR_VIO_DSTR_OBJT_SSL2,       "ssl2",
113      {ROAR_VIO_DEF_TYPE_EOL}},
114 {ROAR_VIO_DSTR_OBJT_SSL3,       "ssl3",
115      {ROAR_VIO_DEF_TYPE_EOL}},
116 {ROAR_VIO_DSTR_OBJT_TLS,        "tls",
117      {ROAR_VIO_DEF_TYPE_EOL}},
118 {ROAR_VIO_DSTR_OBJT_SSLTLS,     "ssltls",
119      {ROAR_VIO_DEF_TYPE_EOL}},
120
121 {ROAR_VIO_DSTR_OBJT_MAGIC,      "magic",
122      {ROAR_VIO_DEF_TYPE_EOL}},
123
124 {ROAR_VIO_DSTR_OBJT_INTERNAL, "INTERNAL",
125      {ROAR_VIO_DEF_TYPE_FILE, ROAR_VIO_DEF_TYPE_SOCKET, ROAR_VIO_DEF_TYPE_FH, ROAR_VIO_DEF_TYPE_SOCKETFH,
126       ROAR_VIO_DEF_TYPE_EOL}},
127 {ROAR_VIO_DSTR_OBJT_EOL, NULL, {ROAR_VIO_DEF_TYPE_EOL}}
128};
129
130int     roar_vio_dstr_get_type(char * str) {
131 int i;
132
133 for (i = 0; _roar_vio_dstr_objs[i].id != ROAR_VIO_DSTR_OBJT_EOL; i++) {
134  if ( strcasecmp(_roar_vio_dstr_objs[i].name, str) == 0 )
135   return _roar_vio_dstr_objs[i].id;
136 }
137
138 return -1;
139}
140
141char *  roar_vio_dstr_get_name(int type) {
142 int i;
143
144 for (i = 0; _roar_vio_dstr_objs[i].id != ROAR_VIO_DSTR_OBJT_EOL; i++) {
145  if ( _roar_vio_dstr_objs[i].id == type )
146   return _roar_vio_dstr_objs[i].name;
147 }
148
149 if ( type == ROAR_VIO_DSTR_OBJT_EOL )
150  return "<<EOL>>";
151
152 return NULL;
153}
154
155int     roar_vio_dstr_init_defaults (struct roar_vio_defaults * def, int type, int o_flags, mode_t o_mode) {
156 if ( def == NULL )
157  return -1;
158
159 memset(def, 0, sizeof(struct roar_vio_defaults));
160
161 def->type    = type;
162 def->o_flags = o_flags;
163 def->o_mode  = o_mode;
164
165 return 0;
166}
167
168int     roar_vio_open_dstr    (struct roar_vio_calls * calls, char * dstr, struct roar_vio_defaults * def, int dnum) {
169 return roar_vio_open_dstr_vio(calls, dstr, def, dnum, NULL);
170}
171
172#define _ret(x) free(dstr); return (x)
173
174int     roar_vio_open_dstr_vio(struct roar_vio_calls * calls,
175                               char * dstr, struct roar_vio_defaults * def, int dnum,
176                               struct roar_vio_calls * vio) {
177 struct roar_vio_dstr_chain chain[ROAR_VIO_DSTR_MAX_OBJ_PER_CHAIN];
178 char * next;
179 char * this;
180 char * name;
181 char * opts;
182 char * dst;
183 char * c;
184 int    inopts;
185 int    type;
186 int    cc = 1; // current chain element
187
188 if ( calls == NULL || dstr == NULL )
189  return -1;
190
191 if ( dnum != 0 && def == NULL )
192  return -1;
193
194 if ( (dstr = strdup(dstr)) == NULL )
195  return -1;
196
197 memset(chain, 0, sizeof(chain));
198
199 chain[0].type = ROAR_VIO_DSTR_OBJT_INTERNAL;
200
201 next = dstr;
202
203 while (next != NULL) {
204  if ( (cc+1) == ROAR_VIO_DSTR_MAX_OBJ_PER_CHAIN ) {
205   _ret(-1);
206  }
207
208  this = next;
209  next = strstr(next, "##");
210
211  if (next != NULL) {
212   *next = 0;
213   next += 2;
214  }
215
216  // we have the current token in 'this'.
217
218  opts   = NULL;
219  dst    = NULL;
220
221  if ( strstr(this, ":") != NULL ) {
222   name   = this;
223   inopts = 0;
224   for (c = this; *c != 0; c++) {
225    if ( *c == '[' ) {
226     *c     = 0;
227     opts   = c + 1;
228     inopts = 1;
229    } else if ( *c == ']' &&  inopts ) {
230     *c     = 0;
231     inopts = 0;
232    } else if ( *c == ':' && !inopts ) {
233     *c     = 0;
234     dst    = *(c+1) == 0 ? NULL : c + 1;
235     break;
236    }
237   }
238  } else {
239   // we need to guess that this is here...
240   // currently we guess this is a file in all cases
241   name = "file";
242   dst  = this;
243  }
244
245  ROAR_WARN("roar_vio_open_dstr_vio(*): name='%s', opts='%s', dst='%s'", name, opts, dst);
246
247  if ( (type = roar_vio_dstr_get_type(name)) == -1 ) {
248   _ret(-1);
249  }
250
251  ROAR_WARN("roar_vio_open_dstr_vio(*): type=0x%.4x(%s)", type, roar_vio_dstr_get_name(type));
252
253  chain[cc].type     = type;
254  chain[cc].opts     = opts;
255  chain[cc].dst      = dst;
256  chain[cc].def      = NULL;
257  chain[cc].vio      = NULL;
258  chain[cc].need_vio = -1;
259  cc++;
260
261 }
262
263 chain[cc].type = ROAR_VIO_DSTR_OBJT_EOL;
264
265 ROAR_WARN("roar_vio_open_dstr_vio(*): chain=%p", chain);
266
267 if ( roar_vio_dstr_parse_opts(chain) == -1 ) {
268  _ret(-1);
269 }
270
271 if ( roar_vio_dstr_set_defaults(chain, cc, def, dnum) == -1 ) {
272  _ret(-1);
273 }
274
275 if ( roar_vio_dstr_build_chain(chain, calls, vio) == -1 ) {
276  _ret(-1);
277 }
278
279 _ret(0);
280}
281
282#undef _ret
283
284int     roar_vio_dstr_parse_opts(struct roar_vio_dstr_chain * chain) {
285 if ( chain == NULL )
286  return -1;
287
288 // TODO: we should add some code here later...
289
290 return 0;
291}
292
293int     roar_vio_dstr_set_defaults(struct roar_vio_dstr_chain * chain, int len, struct roar_vio_defaults * def, int dnum) {
294 struct roar_vio_dstr_chain * c, * next;
295 int i;
296 int tmp[8];
297
298 if ( chain == NULL )
299  return -1;
300
301 if ( def == NULL && dnum != 0 )
302  return -1;
303
304 if ( dnum > 1 ) /* currently not supported */
305  return -1;
306
307 if ( dnum == 0 )
308  def = NULL;
309
310 chain[len].def = def;
311
312 for (i = len; i >= 0; i--) {
313  c    = &chain[i];
314  next = &chain[i-1];
315
316  memset(tmp, 0, sizeof(tmp));
317
318  ROAR_WARN("roar_vio_dstr_set_defaults(*): i=%i, c->type=0x%.4x(%s)", i, c->type & 0xFFFF, roar_vio_dstr_get_name(c->type));
319  ROAR_WARN("roar_vio_dstr_set_defaults(*): i=%i, c->type=0x%.4x(%s): c->def=%p, c->def->type=%i", i, c->type & 0xFFFF,
320                   roar_vio_dstr_get_name(c->type), c->def, c->def == NULL ? -1 : c->def->type);
321
322  c->need_vio = 1;
323
324  switch (c->type) {
325   case ROAR_VIO_DSTR_OBJT_INTERNAL:
326     c->need_vio = 0;
327    break;
328   case ROAR_VIO_DSTR_OBJT_EOL:
329     tmp[0] = 1;
330   case ROAR_VIO_DSTR_OBJT_PASS:
331   case ROAR_VIO_DSTR_OBJT_RE:
332   case ROAR_VIO_DSTR_OBJT_GZIP:
333   case ROAR_VIO_DSTR_OBJT_BZIP2:
334   case ROAR_VIO_DSTR_OBJT_PGP:
335   case ROAR_VIO_DSTR_OBJT_PGP_ENC:
336   case ROAR_VIO_DSTR_OBJT_PGP_STORE:
337   case ROAR_VIO_DSTR_OBJT_SSL1:
338   case ROAR_VIO_DSTR_OBJT_SSL2:
339   case ROAR_VIO_DSTR_OBJT_SSL3:
340   case ROAR_VIO_DSTR_OBJT_TLS:
341   case ROAR_VIO_DSTR_OBJT_MAGIC:
342     if ( tmp[0] )
343      c->need_vio = 0;
344
345     next->def = c->def;
346    break;
347   case ROAR_VIO_DSTR_OBJT_FILE:
348     if ( c->dst == NULL ) /* should we allow multible cascaed file: objects? */
349      return -1;
350
351     c->need_vio = 0;
352     next->def = &(next->store_def);
353     if ( c->def != NULL ) {
354      roar_vio_dstr_init_defaults(next->def, ROAR_VIO_DEF_TYPE_FILE, c->def->o_flags, c->def->o_mode);
355     } else {
356      roar_vio_dstr_init_defaults(next->def, ROAR_VIO_DEF_TYPE_FILE, O_RDONLY, 0644);
357     }
358
359     if ( c->dst[0] == '/' && c->dst[1] == '/' ) {
360      next->def->d.file = c->dst + 1;
361     } else {
362      next->def->d.file = c->dst;
363     }
364    break;
365   case ROAR_VIO_DSTR_OBJT_FH:
366     tmp[0] = 1;
367   case ROAR_VIO_DSTR_OBJT_SOCKETFH:
368     c->need_vio = 0;
369     next->def = &(next->store_def);
370
371     if ( c->def != NULL ) {
372      tmp[2] = c->def->o_flags;
373      tmp[3] = c->def->o_mode;
374     } else {
375      tmp[2] = O_RDONLY;
376      tmp[3] = 0644;
377     }
378
379     if ( !strcasecmp(c->dst, "stdin") ) {
380      tmp[1] = ROAR_STDIN;
381      tmp[2] = O_RDONLY;
382     } else if ( !strcasecmp(c->dst, "stdout") ) {
383      tmp[1] = ROAR_STDOUT;
384      tmp[2] = O_WRONLY;
385     } else if ( !strcasecmp(c->dst, "stderr") ) {
386      tmp[1] = ROAR_STDERR;
387      tmp[2] = O_WRONLY;
388     } else {
389      if ( sscanf(c->dst, "%i", &tmp[1]) != 1 )
390       return -1;
391     }
392
393     roar_vio_dstr_init_defaults(next->def, tmp[0] ? ROAR_VIO_DEF_TYPE_FH : ROAR_VIO_DEF_TYPE_SOCKETFH, tmp[2], tmp[3]);
394     next->def->d.fh = tmp[1];
395    break;
396   default:
397    return -1;
398  }
399
400  ROAR_WARN("roar_vio_dstr_set_defaults(*): i=%i, c->type=0x%.4x(%s): next->def=%p, next->def->type=%i", i,
401                   c->type & 0xFFFF, roar_vio_dstr_get_name(c->type),
402                   next->def, next->def == NULL ? -1 : next->def->type);
403 }
404
405 ROAR_WARN("roar_vio_dstr_set_defaults(*) = 0");
406
407 return 0;
408}
409
410#define _ret(x) roar_vio_close(calls); ROAR_WARN("roar_vio_dstr_build_chain(*) = %i", (x)); return (x)
411
412int     roar_vio_dstr_build_chain(struct roar_vio_dstr_chain * chain, struct roar_vio_calls * calls,
413                                  struct roar_vio_calls * vio) {
414 struct roar_vio_dstr_chain * c;
415 struct roar_vio_defaults   * def;
416 struct roar_vio_calls      * tc, * prev;
417 int i;
418
419 ROAR_WARN("roar_vio_dstr_build_chain(*) = ?");
420
421 if ( chain == NULL || calls == NULL )
422  return -1;
423
424 if ( roar_vio_open_stack(calls) == -1 )
425  return -1;
426
427 ROAR_WARN("roar_vio_dstr_build_chain(*): chain=%p", chain);
428
429 if ( (def = chain->def) != NULL ) {
430  if ( (tc = malloc(sizeof(struct roar_vio_calls))) == NULL ) {
431   _ret(-1);
432  }
433
434  if ( roar_vio_stack_add(calls, tc) == -1 ) {
435   _ret(-1);
436  }
437
438  switch (def->type) {
439   case ROAR_VIO_DEF_TYPE_FILE:
440     if ( roar_vio_open_file(tc, def->d.file, def->o_flags, def->o_mode) == -1 ) {
441      _ret(-1);
442     }
443    break;
444   case ROAR_VIO_DEF_TYPE_SOCKET:
445     _ret(-1);
446    break;
447   case ROAR_VIO_DEF_TYPE_FH:
448     if ( roar_vio_open_fh(tc, def->d.fh) == -1 ) {
449      _ret(-1);
450     }
451    break;
452   case ROAR_VIO_DEF_TYPE_SOCKETFH:
453     if ( roar_vio_open_fh_socket(tc, def->d.fh) == -1 ) {
454      _ret(-1);
455     }
456    break;
457   default:
458     _ret(-1);
459  }
460  prev = tc;
461 } else {
462  prev = vio;
463 }
464
465 for (i = 0; (c = &chain[i])->type != ROAR_VIO_DSTR_OBJT_EOL; i++) {
466  if ( c->need_vio ) {
467   if ( (tc = malloc(sizeof(struct roar_vio_calls))) == NULL ) {
468    _ret(-1);
469   }
470
471   if ( roar_vio_stack_add(calls, tc) == -1 ) {
472    _ret(-1);
473   }
474
475   switch (c->type) {
476    case ROAR_VIO_DSTR_OBJT_PASS:
477      if ( roar_vio_open_pass(tc, prev) == -1 ) {
478       _ret(-1);
479      }
480     break;
481    case ROAR_VIO_DSTR_OBJT_RE:
482      if ( roar_vio_open_re(tc, prev) == -1 ) {
483       _ret(-1);
484      }
485     break;
486    case ROAR_VIO_DSTR_OBJT_GZIP:
487      if ( roar_vio_open_gzip(tc, prev, -1) == -1 ) {
488       _ret(-1);
489      }
490     break;
491    case ROAR_VIO_DSTR_OBJT_BZIP2:
492    case ROAR_VIO_DSTR_OBJT_PGP:
493      if ( roar_vio_open_pgp_decrypt(tc, prev, NULL) == -1 ) {
494       _ret(-1);
495      }
496     break;
497    case ROAR_VIO_DSTR_OBJT_PGP_ENC:
498    case ROAR_VIO_DSTR_OBJT_PGP_STORE:
499      if ( roar_vio_open_pgp_store(tc, prev, ROAR_VIO_PGP_OPTS_NONE) == -1 ) {
500       _ret(-1);
501      }
502     break;
503    case ROAR_VIO_DSTR_OBJT_SSL1:
504    case ROAR_VIO_DSTR_OBJT_SSL2:
505    case ROAR_VIO_DSTR_OBJT_SSL3:
506    case ROAR_VIO_DSTR_OBJT_TLS:
507    case ROAR_VIO_DSTR_OBJT_MAGIC:
508      _ret(-1);
509     break;
510    default:
511      _ret(-1);
512   }
513
514   prev = tc;
515  } // else we can skip to the next :)
516 }
517
518 ROAR_WARN("roar_vio_dstr_build_chain(*) = 0");
519 return 0;
520}
521
522#undef _ret
523
524//ll
Note: See TracBrowser for help on using the repository browser.