开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
harglists.c
资源名称：nessus-libraries_2.2.10.orig.tar.gz　[点击查看]
上传用户：tjescc
上传日期：2021-02-23
资源大小：419k
文件大小：26k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

harglists.c：源码内容
  1. /*
  2.  *  Copyright (c) Nessus Consulting S.A.R.L., 2000 - 2001
  3.  *  Email: office@nessus.com
  4.  *
  5.  *  This library is free software; you can redistribute it and/or
  6.  *  modify it under the terms of the GNU Library General Public
  7.  *  License as published by the Free Software Foundation; either
  8.  *  version 2 of the License, or (at your option) any later version.
  9.  *
  10.  *  This library is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  *  Library General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU General Public License 
  16.  *  along with this library; if not, write to the Free Software
  17.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  *
  19.  *  $Id: harglists.c,v 1.37.2.1 2005/03/22 01:31:46 renaud Exp $
  20.  *
  21.  * Author: Jordan Hrycaj <jordan@mjh.teddy-net.com>
  22.  *
  23.  * Jordan re-wrote Renauds idea of an arglists management on top
  24.  * of the hash list manager
  25.  */
  27. #ifdef HAVE_CONFIG_H
  28. #include "config.h"
  29. #endif
  31. #include "hlst.h"
  33. #define EXPORTING
  34. #include <includes.h>
  35. #include <errno.h>
  37. #define __HARG_INTERNAL__
  38. #include "harglists.h"
  40. #ifdef HAVE__ALLOCA
  41. #define alloca _alloca
  42. #define HAVE_ALLOCA
  43. #endif
  45. /* set this flag if you want to dump create/destroy messages */
  46. #undef HARG_CREATE_DEBUG
  48. /* activates the lost-losts tracker functions harg_tracker_dunp()
  49.    and harg_tracket_flush() */
  50. #undef HARG_LIST_TRACKER
  52. #define HARG_DEBUG 6 /* log level ranging [0..9] (9 is more output) */
  54. /* ------------------------------------------------------------------------- *
  55.  *                   private definitions: debugging stuff                    *
  56.  * ------------------------------------------------------------------------- */
  58. #ifdef HARG_DEBUG
  59. # define IFDEBUG(cmd) cmd
  60. # define XTAG(s) __FILE__ "(%u): " s ".n", __LINE__
  61. #else
  62. # define IFDEBUG(cmd)
  63. #endif
  65. /* same as *HLOG, below but for debugging, call it  XPRINT (("problem", ..)) */
  66. #define XPRINT(l,msg) IFDEBUG ({if ((l)<=dbglevel && xlog!=0)(*xlog) msg;})
  68. /* log level dependent convenience macros */
  69. #define XPRINT0(msg) XPRINT (0,msg)
  70. #define XPRINT1(msg) XPRINT (1,msg)
  71. #define XPRINT2(msg) XPRINT (2,msg)
  72. #define XPRINT3(msg) XPRINT (3,msg)
  73. #define XPRINT4(msg) XPRINT (4,msg)
  74. #define XPRINT5(msg) XPRINT (5,msg)
  75. #define XPRINT6(msg) XPRINT (6,msg)
  76. #define XPRINT7(msg) XPRINT (7,msg)
  77. #define XPRINT8(msg) XPRINT (8,msg)
  78. #define XPRINT9(msg) XPRINT (9,msg)
  80. /* ------------------------------------------------------------------------- *
  81.  *                      private definitions                                  *
  82.  * ------------------------------------------------------------------------- */
  84. /* XMALLOC returns memory initialized to zero */
  85. #define XMALLOC(x)  emalloc(x)
  86. #define XFREE(x)    efree(&(x))
  88. #define NEED_XREALLOC /* locally installed, no mem zero needed */
  89. #define XREALLOC(x,n) xrealloc(x,n)
  91. #ifdef DMALLOC
  92. #undef NEED_XREALLOC
  93. #undef XREALLOC
  94. #define XREALLOC(x,n) realloc(x,n)
  95. #endif
  98. /* local on-the-stack memory allocation */
  99. #ifdef HAVE_ALLOCA
  100. # define XALLOCA(x)  alloca(x)
  101. # define XDEALLOC(x) /* nothing */
  102. #else
  103. # define XALLOCA(x)  XMALLOC(x)
  104. # define XDEALLOC(x) XFREE(x)
  105. #endif
  107. typedef /* data part for the data type, following */
  108. struct _harg_aligned {
  109.   union {
  110.     char data [1]; 
  111.     void  *ptr[1]; /* force alignment */
  112.   } d;
  113. } harg_aligned ;
  115. typedef /* general data type record/slot */
  116. struct _harg {
  117.   hargtype_t type;
  118.   unsigned   size;
  120.   /* type ARG_STRING, ARG_STUCT data are stored as a data block
  121.      of given size - all other data types are stored as (void*) */
  122.   harg_aligned d;
  123.   /* varable length, struct aligned  */
  124. } harg;
  127. typedef /* recursive list copying */
  128. struct _copy_cb {
  129.   harglst *trg;
  130.   int    depth;  /* recursion depth */
  131. } copy_cb ;
  134. typedef /* call back function's state buffer */
  135. struct _do_for_all_cb_state {
  136.   void *state ;
  137.   int (*cb_fn)(void*,void*,hargtype_t,unsigned,hargkey_t*) ;
  138. } do_for_all_cb_state ;
  141. typedef /* custum sort call back function descriptor */
  142. struct _csts_desc {
  143.   harglst *a;
  145.   void *cmp_desc ;
  146.   int (*cmp)(void*, harglst*,
  147.      hargkey_t  *left_key, hargtype_t  left_type,
  148.      hargkey_t *right_key, hargtype_t right_type);
  149. } csts_desc ;
  153. static void debug (const char *, long, long);
  155. /* ------------------------------------------------------------------------- *
  156.  *                       private variable                                    *
  157.  * ------------------------------------------------------------------------- */
  161. #ifdef HARG_LIST_TRACKER
  162. static hlst *harg_tracker;
  163. #endif
  165. /* default logger */
  166. static void (*xlog) (const char *, ...) = 0;
  167. IFDEBUG (static int dbglevel = HARG_DEBUG);
  169. /* ------------------------------------------------------------------------- *
  170.  *                   private functions: helpers                              *
  171.  * ------------------------------------------------------------------------- */
  173. /* the memory size of the record containing the data block */
  174. #define HARG_SIZE(   len) (sizeof (harg) - sizeof (harg_aligned) + (len))
  175. #define HARG_RECSIZE(rec) HARG_SIZE((rec)->size)
  177. /* get the byte offset of a field */
  178. #define STRUCT_OFFSET(type, field) 
  179. ((char*)(&((type*)0)->field)-(char*)0)
  181. /* given a pointer to field "field" from a structure of type "type",
  182.    get the structure pointer */
  183. #define REVERT_FIELD_PTR(p, type, field)  
  184. ((type*)(((char*)p) - STRUCT_OFFSET (type,field)))
  186. /* key length depending on the data type */
  187. #define klen_by_type(t)  (is_ptrkey_type(t) ? sizeof (void*) : 0)
  189. /* if enabled, compare ignoring remote bits */
  190. #define falsify_given_type(s,t) 
  191.         (is_specific_type (s) && get_local_type ((s)^(t)) != 0)
  193. /* compare ignoring remote and ptr key bits */
  194. #define verify_simple_type(s,t) (get_simple_type ((s)^(t)) == 0)
  196. /* compare ignoring ptr key bits */
  197. #define verify_yekrtp_type(s,t)  (get_yekrtp_type ((s)^(t)) == 0)
  199. #ifdef NEED_XREALLOC
  200. static void *
  201. xrealloc
  202.   (void       *p,
  203.    unsigned size)
  204. {
  205.   void *q = realloc (p, size) ;
  206.   if (q == 0) {
  207.     /* on out of memory, let XMALLOC do the aborting job */
  208.     q = XMALLOC (size) ;
  209.     memcpy (q, p, size) ;
  210.     XFREE (p) ;
  211.     return q;
  212.   }
  213.   return q;
  214. }
  215. #endif /* NEED_XREALLOC */
  217. #ifdef HARG_LIST_TRACKER
  218. static void
  219. harg_tracker_add
  220.   (harglst *a)
  221. {
  222.   void **R;
  223.   if (harg_tracker == 0 && (harg_tracker = create_hlst (100,0,0)) == 0)
  224.     return ;
  225.   if ((R = find_hlst (harg_tracker, (char*)&a, sizeof (void*))) == 0 &&
  226.       (R = make_hlst (harg_tracker, (char*)&a, sizeof (void*))) == 0)
  227.     return;
  228.   *R = a;
  229. }
  231. static void
  232. harg_tracker_delete
  233.   (harglst *a)
  234. {
  235.   delete_hlst (harg_tracker, (char*)&a, sizeof (void*));
  236. }
  238. #else
  239. #define harg_tracker_add(x)
  240. #define harg_tracker_delete(x)
  241. #endif
  244. #ifdef  HARG_CREATE_DEBUG
  245. #define HARG_DEBUG
  247. static void
  248. say_creating
  249.   (void    *list,
  250.    unsigned size)
  251. {
  252.   debug ("Creating harg -> 0x%lx{%u}", (long)list, size);
  253. }
  255. static void
  256. say_closing
  257.   (void    *list,
  258.    unsigned flag)
  259. {
  260.   char f [200] = "Closing harg -> 0x%lx" ;
  261.   int n = 0 ;
  262.   if (flag & H_sREMOTE) 
  263.     strcat (f, n ++ ? "|H_sREMOTE"  : ", flags=H_sREMOTE");
  264.   if (flag & H_sWRTHRU) 
  265.     strcat (f, n ++ ? "|H_sWRTHRU"  : ", flags=H_sWRTHRU");
  266.   if (flag & H_sRECURSE)
  267.     strcat (f, n ++ ? "|H_sRECURSE" : ", flags=H_sRECURSE");
  268.   debug (f, (long)list, 0);
  269. }
  271. #else
  272. #define say_creating(x,y)
  273. #define say_closing(x,y)
  274. #endif /* HARG_CREATE_DEBUG */
  276. #ifdef HARG_DEBUG
  277. static void
  278. message
  279.   (const char *s,
  280.    const char *f,
  281.    long        u,
  282.    long        v,
  283.    const char *t)
  284. {
  285.   fputs (s, stderr);
  286.   fprintf (stderr, f, u, v);
  287.   fputs (t, stderr);
  288. # ifdef _WIN32
  289.   fputc ('r', stderr);
  290. # endif 
  291.   fputc ('n', stderr);
  292. }
  294. static void
  295. debug
  296.   (const char *s,
  297.    long        u,
  298.    long        v)
  299. {
  300.   message ("DEBUG: ", s, u, v, ".");
  301. }
  302. #endif /* HARG_DEBUG */
  304. static harg*
  305. create_harg
  306.   (hargtype_t type,
  307.    void      *data,
  308.    unsigned   size)
  309. {
  310.   harg *h ; 
  312.   if (!is_blob_type (type) && size == 0)
  313.     size = sizeof (void*);
  314.   
  315.   h = XMALLOC (HARG_SIZE (size));
  316.   h->type = type ;
  317.   h->size = size ;
  319.   if (!is_blob_type (type)) {
  320.     h->d.d.ptr [0] = data ;
  321.     return h;
  322.   }
  324.   if (verify_simple_type (type, HARG_STRING) && size != 0)
  325.     /* last character is '' */
  326.     h->d.d.data [ -- size] = '' ;
  328.   if (size != 0 && data != 0)
  329.     memcpy (h->d.d.data, data, size);
  330.   return h;
  331. }
  333. /* ------------------------------------------------------------------------- *
  334.  *                   private functions: local call backs                     *
  335.  * ------------------------------------------------------------------------- */
  337. static void
  338. clean_up
  339.   (harglst     *a,
  340.    harg     *data,
  341.    hargkey_t *key,
  342.    unsigned   len)
  343. {
  344.   /* last step, delete descriptor */
  345.   if (data == 0) {
  346.     if (a == 0) 
  347.       return ;
  348.     if (a->sorter != 0)
  349.       XFREE (a->sorter) ;
  350.     XFREE (a) ;
  351.     return ;
  352.   }
  353.   /* recursively delete sublist */
  354.   if (is_harglst_type (data->type) && 
  355.       a != 0 && (a->destroy_mode & H_sRECURSE))
  356.     harg_close_any (data->d.d.ptr [0], a->destroy_mode);
  357.   
  358. # ifdef ARG_ARGLIST
  359.   else
  360.     switch (data->type) {
  361.     case HARG_ARGLIST:
  362.     case HARG_PARGLIST:
  363.       /* recursively delete sublist */
  364.       if (a != 0 && (a->destroy_mode & H_sRECURSE))
  365. arg_free_all (data->d.d.ptr [0]);
  366.     default:
  367.      break;
  368.     }
  369. # endif
  371.   XFREE (data);
  372. }
  375. static int 
  376. do_for_all_cb
  377.   (do_for_all_cb_state *s, 
  378.    harg                *h,
  379.    hargkey_t         *key, 
  380.    unsigned           len)
  381. {
  382.   return (s->cb_fn) 
  383.     (s->state, 
  384.      is_blob_type (h->type) ?h->d.d.data :h->d.d.ptr [0],
  385.      h->type, h->size, key);
  386. }
  392. static harg*
  393. a_copy
  394.   (copy_cb  *desc,
  395.    harg     *data, /* from the source list */
  396.    hargkey_t *key,
  397.    unsigned   len)
  398. {
  399.   unsigned size ;
  400.   harglst *a, *b, *c ;
  402.   if (data == 0) { /* may happen, bootstrap also */
  403.     errno = 0 ;
  404.     return 0;
  405.   }
  407.   /* stupidly copying sensless data ?? */
  408.   if (is_harglst_type (data->type) && (a = data->d.d.ptr [0]) != 0) {
  410.     c = desc->trg ; /* == 0  on bootstrap level */
  412.       if (++ desc->depth >= HLST_MAX_RDEPTH) {
  413. errno = ELOOP ;  /* recursion overflow ? */
  414. return 0;
  415.       }
  416.       /* recursively populate the sublist */    
  417.       desc->trg =       /* mark it non-bootstrap level */
  418. b = XMALLOC (sizeof (harglst)) ;
  419.       if ((b->x = copy_hlst 
  420.    (a->x, query_hlst_size (a->x),
  421.     (void*(*)(void*,void*,char*,unsigned))a_copy, desc,
  422.     (void (*)(void*,void*,char*,unsigned))clean_up, 0)) == 0) {
  423. int e = errno ;
  424. XFREE    (b);
  425. errno = e ;
  426. return 0;
  427.       }
  429.     -- desc->depth ;                     /* end recursion */
  430.     if ((desc->trg = c) == 0)                  /* restore */
  431.       return (harg*)b;      /* return value for bootstrap */
  432.     
  433.     /* local type applies, only */
  434.     return create_harg (get_local_type (data->type), b, 0);
  435.   }
  436.   
  437.   /* return a copy of the data block */
  438.   size = HARG_RECSIZE (data);
  439.   return memcpy (XMALLOC (size), data, size);
  440. }
  443. static int
  444. __csts_cb /* custum sort call back function descriptor */
  445.   (void *desc,
  446.    const char  *left_key, unsigned  left_klen,
  447.    const char *right_key, unsigned right_klen)
  448. {
  449.   harglst   *a = desc ;
  450.   csts_desc *s = a->sorter ;
  452.   harg  **left_R = (harg**)find_hlst (a->x,  left_key,  left_klen);
  453.   harg **right_R = (harg**)find_hlst (a->x, right_key, right_klen);
  454.   
  455.   return (*s->cmp) 
  456.     (s->cmp_desc, a,
  457.      left_key,  get_local_type  ((*left_R)->type),
  458.      right_key, get_local_type ((*right_R)->type));
  459. }
  461. /* ------------------------------------------------------------------------- *
  462.  *               private functions: data tree dumper                         *
  463.  * ------------------------------------------------------------------------- */
  465. static void
  466. do_newlevel
  467.   (void)
  468. {
  469.   fputs ("n", stderr);
  470. }
  472. static void
  473. do_indent
  474.   (int level)
  475. {
  476.   while (level -- > 0)
  477.     fputs ("   ", stderr);
  478.   fputs (" ", stderr);
  479. }
  481. static void
  482. do_printf
  483.   (const char *f,
  484.    harg      **R,
  485.    void       *a,
  486.    int     flags,
  487.    int     ptype,
  488.    unsigned  arg)
  489. {
  490.   if (R != 0) {
  491.     char *s = query_key_hlst ((void**)R) ;
  492.     if (ptype)
  493.       fprintf (stderr, "<0x%04X/%d> = ", (void*)s,(int)(s));
  494.     else
  495.       fprintf (stderr, "<%s> = ", s);
  496.   } else {
  497.     fprintf (stderr, "list");
  498.   }
  499.   fprintf (stderr, f, a, arg);
  500.   fputs ("n", stderr);
  501. }
  504. static void **
  505. harg_walk_next_ptr
  506.   (hargwalk *w)
  507. {
  508.   return next_hlst_search ((hsrch*)w) ;
  509. }
  514. static void
  515. do_harg_dump
  516.   (harglst *a,
  517.    int  level)
  518. {
  519.   hargwalk *w ;
  520.   harg **R, *r ;
  522.   if(a == 0 || (w = harg_walk_init (a)) == 0) {
  523.     do_printf ("-error; no such list!n",0,0,0,0,0);
  524.     return;
  525.   } 
  527.   while ((R = (harg**)harg_walk_next_ptr (w)) != 0) {
  528.     int ptrky, flags = 0;
  529.     do_indent (level);
  530.     if ((r = *R) == 0) {
  531.       do_printf ("Warning: NULL entry in listn",0,0,0,0,0);
  532.       continue ;
  533.     }
  534.     ptrky = (is_ptrkey_type (r->type) != 0);
  535.     switch (get_simple_type (r->type)) {
  536.     case HARG_STRING:
  537.       do_printf (""%s"",  R, (void*)r->d.d.data, flags, ptrky, 0);
  538.       continue ;
  539.     case HARG_BLOB:
  540.       do_printf ("%#x[%u]", R, (void*)r->d.d.data, flags, ptrky, r->size);
  541.       continue ;
  542. #ifdef ARG_ARGLIST
  543.     case HARG_ARGLIST:
  544.       do_newlevel ();
  545.       do_printf ("(old mode>) sublist ...", R, 0, flags, ptrky, 0);
  546.       arg_dump (r->d.d.ptr [0], level+1);
  547.       continue ;
  548. #endif
  549.     case HARG_HARG:
  550.       /* do_newlevel (); */
  551.       if (is_remote_type (r->type))
  552. do_printf ("remote sublist{%s} ...", R, r->d.d.ptr+1, flags, ptrky, 0);
  553.       else
  554. do_printf ("sublist{%#x} ...", R, r->d.d.ptr [0], flags, ptrky, 0);
  555.       do_harg_dump (r->d.d.ptr [0], level+1);
  556.       continue ;
  557.     case HARG_INT:
  558.       do_printf ("%d",  R, r->d.d.ptr [0], flags, ptrky, 0);
  559.       continue;
  560.     default:
  561.       do_printf ("*%#x", R, r->d.d.ptr [0], flags, ptrky, 0);
  562.     }
  563.   }
  564.   harg_walk_stop (w);
  565. }
  567. /* ------------------------------------------------------------------------- *
  568.  *                      private functions                                    *
  569.  * ------------------------------------------------------------------------- */
  571. static harg *
  572. get_harg_entry
  573.   (harglst      *a,
  574.    const char *key,
  575.    unsigned    len)
  576. {
  577.   harg **R, *r ;
  579.   if (a == 0) { 
  580.     errno = EINVAL; 
  581.     return 0; 
  582.   }
  583.     if ((R = (harg**)find_hlst (a->x, key, len)) == 0)
  584.       return 0;
  586.   
  587.   if ((r = *R) != 0)
  588.     return r;
  589.   /* zombie, should not happen, anyway */
  590.   delete_hlst (a->x, key, len);
  591.   errno = ENOENT ;
  592.   return 0;
  593. }
  602. /* ------------------------------------------------------------------------- *
  603.  *                 public functions: open/close management                   *
  604.  * ------------------------------------------------------------------------- */
  606. harglst*
  607. harg_create 
  608.   (unsigned size)
  609. {
  610.   harglst* h = XMALLOC (sizeof (harglst)) ;
  611.   h->x = create_hlst 
  612.     /* never returns NULL */
  613.     (size, (void(*)(void*,void*,char*,unsigned))clean_up, h);
  614.   say_creating (h, size);
  615.   harg_tracker_add (h);
  616.   return h ;
  617. }
  620. void
  621. harg_close_any
  622.   (harglst *a,
  623.    int   flag)
  624. {
  625.   if (a == 0)
  626.     return ;
  627.   a->destroy_mode = flag ;
  628.   say_closing (a,flag);
  629.   harg_tracker_delete (a);
  630.   destroy_hlst (a->x); /* implicitely frees a == call back descriptor */
  631. }
  634. harglst*
  635. harg_dup
  636.   (harglst*    a,
  637.    unsigned size)
  638. {
  639.   copy_cb desc ;
  640.   harg data ;
  642.   /* sanity check */
  643.   if (a == 0) {
  644.     errno = EINVAL;
  645.     return 0; 
  646.   }
  648.   desc.trg         = 0 ;
  649.   desc.depth       = 0 ;
  650.   data.type        = HARG_HARG ;
  651.   data.d.d.ptr [0] = a ;
  653.   return (harglst*)a_copy (&desc, &data, 0, 0);
  654. }
  657. /* ------------------------------------------------------------------------- *
  658.  *               public functions: varable access - modify                   *
  659.  * ------------------------------------------------------------------------- */
  661. hargkey_t*
  662. harg_addt
  663.   (harglst      *a,
  664.    hargkey_t  *key,
  665.    hargtype_t type,
  666.    int   overwrite,
  667.    unsigned   size,
  668.    void     *value)
  669. {
  670.   harg **R, *r ;
  672.   /* depending on the key type get its length */
  673.   int klen = klen_by_type (type);;
  675.   /* sanity check */
  676.   if (a == 0 || key == 0 ||
  677.       size == 0 && ((value == 0) && is_blob_type (type) ||
  678.     verify_simple_type (type, HARG_BLOB))) {
  679.     errno = EINVAL; 
  680.     return 0;
  681.   }
  683.   if (verify_simple_type (type, HARG_STRING)) {
  684.     if (size == 0) /* need a terminating '' */
  685.       size = strlen (value) + 1 ;
  686.     else
  687.       size ++ ;
  688.   }
  691.     R = (harg**)find_hlst (a->x, key, klen);
  693.   
  694.   if (R != 0) {
  695.     r = *R ;
  696.     /* record exists, do we need to overwrite ? */
  697.     if (!overwrite && type == r->type)
  698.       return query_key_hlst ((void**)R);
  699.     /* reuse the data block if the sizes did not change */
  700.     if (r->size == size) {
  701.       r->type = type ;
  702.       if (type == HARG_STRING || type == HARG_BLOB) {
  703. if (size)
  704.   memcpy (r->d.d.data, value, size);
  705.       } else {
  706. r->d.d.ptr [0] = value;
  707.       }
  708.       return query_key_hlst ((void**)R);
  709.     }
  710.     /* sizes have changed - reallocate but keep ID */
  711.     *R = create_harg (type, value, size);
  712.     XFREE (r);
  713.     return query_key_hlst ((void**)R);
  714.   }
  716.   /* no such value - create anew */
  717.   if ((R = (harg**)make_hlst (a->x, key, klen)) != 0) {
  718.     *R = create_harg (type, value, size);
  719.     return query_key_hlst ((void**)R);
  720.   }
  721.   /* cannot happen */
  723.  
  724.   return 0; 
  725. }
  728. int
  729. harg_set_valuet
  730.   (harglst      *a,
  731.    hargkey_t  *key,
  732.    hargtype_t type,
  733.    unsigned   size,
  734.    void     *value)
  735. {
  736.   harg **R, *r ;
  737.   int klen = klen_by_type (type);
  739.   /* sanity check */
  740.   if (a == 0 || key == 0 ||
  741.       size == 0 && (value == 0 && is_blob_type (type) ||
  742.     verify_simple_type (type, HARG_BLOB))) {
  743.     errno = EINVAL; 
  744.     return -1;
  745.   }
  746.   
  748.     R = (harg**)find_hlst (a->x, key, klen);
  750.   if ((r = *R) == 0) { /* zombie, should not happen, anyway */
  751.     delete_hlst (a->x, key, klen);
  752.     errno = ENOENT ;
  753.     return -1;
  754.   }
  755.   if (falsify_given_type (type, (*R)->type)) {
  756.     errno = EPERM;  /* not permitted */
  757.     return -1;
  758.   }
  759.   if (is_blob_type (r->type) == 0) {
  760.     r->d.d.ptr [0] = value ; /* the quick way */
  761.     return 0;
  762.   }
  763.   if (verify_simple_type (r->type, HARG_STRING)) {
  764.     if (size == 0) /* need a terminating '' */
  765.       size = strlen (value) + 1 ;
  766.     else
  767.       size ++ ;
  768.   }
  769.   /* remains to any blob type */
  770.   if (r->size != size) { /* reallocate that entry */
  771.     *R = create_harg (r->type, value, size);
  772.     XFREE (r);
  773.     return 0;
  774.   } 
  775.   if (value != 0) {
  776.     if (verify_simple_type (r->type, HARG_STRING))
  777.       /* the string terminator may be on protected memory */
  778.       r->d.d.data [-- size] = '' ;
  779.     memcpy (r->d.d.data, value, size);
  780.   }
  781.   return 0;
  782. }
  785. int
  786. harg_renamet
  787.   (harglst       *a,
  788.    hargkey_t   *key,
  789.    hargtype_t  type,
  790.    hargkey_t  *nkey,
  791.    hargtype_t ntype)
  792. {
  793.   harg **S, **R, *r ;
  794.   int same_keys, klen = klen_by_type (type);
  796.   /* sanity check */
  797.   if (a == 0) {
  798.     errno = EINVAL; 
  799.     return -1; 
  800.   }
  803.     R = (harg**)find_hlst (a->x, key, klen);
  806.   if ((r = *R) == 0) { /* zombie, should not happen, anyway */
  807.     delete_hlst (a->x, key, klen);
  808.     errno = ENOENT ;
  809.     return -1;
  810.   }
  811.   /* check for a specific source type */
  812.   if (falsify_given_type (type, r->type)) {
  813.     errno = EPERM ;
  814.     return -1;
  815.   }
  816.   same_keys = 
  817.     nkey == 0 || 
  818.     (is_ptrkey_type  (type) && 
  819.      is_ptrkey_type (ntype) &&
  820.      memcmp (key, nkey, sizeof (void*)) == 0) ||
  821.     (is_ptrkey_type  (type) == 0 && 
  822.      is_ptrkey_type (ntype) == 0 &&
  823.      strcmp (key, nkey) == 0)
  824.     ? 1 
  825.     : 0 
  826.     ;
  827.   if (r->type == ntype && same_keys)
  828.     return 0 ; /* nothing to do */
  830.   /* check target type groups */
  831.   if (is_blob_type   (ntype) &&   is_blob_type (r->type) ||
  832.       is_scalar_type (ntype) && is_scalar_type (r->type) ||
  833.       is_specific_type (ntype) == 0) {
  834.     if (same_keys == 0) {
  835.       /* make new index */
  836.       if ((S = (harg**)make_hlst (a->x, nkey, klen_by_type (ntype))) == 0)
  837. return -1;
  838.       *S = *R;
  839.       *R = 0;
  840.       delete_hlst (a->x, key, klen);
  841.     }
  842.     if (is_specific_type (ntype))
  843.       r->type = ntype ;
  844.     return 0;
  845.   }
  846.   errno = EPERM;  /* not permitted */
  847.   return -1 ;
  848. }
  852. int
  853. harg_removet
  854.   (harglst      *a,
  855.    hargkey_t  *key,
  856.    hargtype_t type)
  857. {
  858.   int klen = klen_by_type (type) ;
  859.   harg **R = 0;
  861.   /* sanity check */
  862.   if (a == 0 || key == 0) { 
  863.     errno = EINVAL; 
  864.     return -1; 
  865.   }
  868.     if (is_specific_type (type) && 
  869. (R = (harg**)find_hlst (a->x, key, klen)) == 0) {
  870.       errno = ENOENT ;  /* no such record */
  871.       return -1 ;
  872.     }
  875.   if (R != 0 && *R != 0 && falsify_given_type (type, (*R)->type)) {
  876.     errno = EPERM ;
  877.     return -1;
  878.   }
  879.   return delete_hlst (a->x, key, klen);
  880. }
  883. /* ------------------------------------------------------------------------- *
  884.  *               public functions: varable access - retrieve                 *
  885.  * ------------------------------------------------------------------------- */
  887. void * /* same as above, but with type check */
  888. harg_get_valuet
  889.   (harglst      *a,
  890.    hargkey_t  *key,
  891.    hargtype_t type)
  892. {
  893.   harg *r ;
  894.   
  895.   if ((r = get_harg_entry (a, key, klen_by_type (type))) == 0)
  896.     return 0;
  898.   /* check for strict type checking */
  899.   if (falsify_given_type (type, r->type)) {
  900.     errno = EPERM ;
  901.     return 0;
  902.   }
  903.   return is_blob_type (r->type) ? r->d.d.data : r->d.d.ptr [0] ;
  904. }
  907. int
  908. harg_inct
  909.   (harglst      *a,
  910.    hargkey_t  *key,
  911.    hargtype_t type,
  912.    incmode_t incop,
  913.    int         inc)
  914. {
  915.   harg *r, **R ;
  916.   int klen = klen_by_type (type);
  918.   /* sanity check */
  919.   if (a == 0) {
  920.     errno = EINVAL;
  921.     return -1; 
  922.   }
  924.   /* type may be 0, or HARG_ANY */
  925.   type = is_ptrkey_type (type) ?HARG_PINT :HARG_INT ;
  926.   
  928.     R = (harg**)find_hlst (a->x, key, klen);
  931.   /* no such entry, yet */
  932.   if (R == 0 || (r = *R) == 0) { 
  933.     if (inc_op_creates_record (incop)) {
  934.       if (R == 0 && (R = (harg**)make_hlst (a->x, key, klen)) == 0)
  935. return -1;
  936.       *R = create_harg (type, (void*)inc, sizeof (int));
  937.       errno = 0;
  938.       return (int)(*R)->d.d.ptr [0];
  939.     }
  940.     errno = ENOENT;
  941.     return -1;
  942.   }
  944.   /* entry exists, already */
  945.   if (!verify_simple_type (r->type, HARG_INT)) {
  946.     errno = EPERM;
  947.     return -1;
  948.   }
  950.   /* increment */
  951.   if (inc_op_increments_record (incop)) {
  952.     if (inc_op_wants_0_record (incop) && r->d.d.ptr [0] != 0) {
  953.       errno = EEXIST;
  954.       return -1;
  955.     }
  956.     r->d.d.ptr [0] = (void*)((int)(r->d.d.ptr [0]) + inc) ;
  957.     return (int)r->d.d.ptr [0];
  958.   }
  960.   /* decrement */
  961.   if (inc_op_notnegtv_record (incop) && (int)r->d.d.ptr [0] < inc) {
  962.     errno = ERANGE;
  963.     return -1;
  964.   }
  965.   if (inc_op_notpostv_record (incop) && (int)r->d.d.ptr [0] > inc) {
  966.     errno = ERANGE;
  967.     return -1;
  968.   }
  969.   if (inc_op_destroy0_record (incop) && (int)r->d.d.ptr [0] <= inc) {
  970.     delete_hlst (a->x, key, klen);
  971.     return errno = 0;
  972.   }
  973.   r->d.d.ptr [0] = (void*)((int)(r->d.d.ptr [0]) - inc) ;
  974.   errno = 0 ;
  975.   return (int)r->d.d.ptr [0];
  976. }
  978. void harg_sort(harglst *a) {
  979. sort_hlst(a->x);
  980. }
  984. int
  985. harg_csort
  986.   (harglst      *a,
  987.    int (*fn)(void*, harglst*,
  988.      hargkey_t  *left_key, hargtype_t  left_type,
  989.      hargkey_t *right_key, hargtype_t right_type),
  990.    void *fn_desc)
  991. {
  992.   csts_desc *s;
  994.   if (a == 0) {
  995.     errno = EINVAL; 
  996.     return 0; 
  997.   }
  998.   if (fn == 0) {
  999.     if (a->sorter == 0) {
  1000.       XFREE (a->sorter);
  1001.       a->sorter = 0;
  1002.     }
  1003.     return csort_hlst (a->x, 0, 0);
  1004.   }
  1006.   /* need some record space */
  1007.   if ((s = a->sorter) == 0)
  1008.     a->sorter = s = XMALLOC (sizeof (csts_desc));
  1010.   s->cmp      = fn ;
  1011.   s->cmp_desc = fn_desc;
  1013.   return csort_hlst (a->x, __csts_cb, a);
  1014. }
  1017. hargkey_t *
  1018. harg_get_ntht
  1019.   (harglst      *a,
  1020.    unsigned    inx,
  1021.    hargtype_t type)
  1022. {
  1023.   harg **R ;
  1024.   if (a == 0) {
  1025.     errno = EINVAL; 
  1026.     return 0; 
  1027.   }
  1031.     sort_hlst (a->x);
  1032.     if ((R = (harg**)inx_hlst (a->x, inx)) == 0)
  1033.       return 0 ;
  1037.   /* check for strict type cheking */
  1038.   if (falsify_given_type (type, (*R)->type)) {
  1039.     errno = EPERM ;
  1040.     return 0;
  1041.   }
  1042.   return query_key_hlst ((void**)R);    
  1043. }
  1045. hargtype_t
  1046. harg_get_typet
  1047.   (harglst      *a,
  1048.    hargkey_t  *key,
  1049.    hargtype_t type)
  1050. {
  1051.   harg *r = get_harg_entry (a, key, klen_by_type (type)) ;
  1052.   return r == 0
  1053.     ? 0 
  1054.     : get_local_type (r->type)
  1055.     ;
  1056. }
  1058. unsigned
  1059. harg_get_sizet
  1060.   (harglst *     a,
  1061.    hargkey_t  *key,
  1062.    hargtype_t type)
  1063. {
  1064.   harg *r = get_harg_entry (a, key, klen_by_type (type)) ;
  1065.   return r == 0 
  1066.     ? -1
  1067.     : (r->type & RHARG_ANY & RHARG_PANY) ? sizeof (void*) : r->size
  1068.     ;
  1069. }
  1072. /* ------------------------------------------------------------------------- *
  1073.  *               public functions: varable access - retrieve                 *
  1074.  * ------------------------------------------------------------------------- */
  1076. hargwalk*
  1077. harg_walk_init
  1078.   (harglst *a)
  1079. {
  1080.   if (a == 0) {
  1081.     errno = EINVAL; 
  1082.     return 0; 
  1083.   }
  1086.   return (hargwalk*)open_hlst_search (a->x);
  1087. }
  1090. hargkey_t*
  1091. harg_walk_nextT
  1092. (hargwalk        *w,
  1093.    hargtype_t *Type)
  1094. {
  1095.   harg **P ;
  1096.   if ((P =(harg**)harg_walk_next_ptr (w)) == 0)
  1097.     return 0;
  1098.   if (Type != 0)
  1099.     *Type = (*P)->type ;
  1100.   return query_key_hlst ((void**)P) ;
  1101. }
  1104. void
  1105. harg_walk_stop
  1106.   (hargwalk *w)
  1107. {
  1108.   close_hlst_search ((hsrch*)w);
  1109. }
  1111. int
  1112. harg_do
  1113.   (harglst    *a,
  1114.    int (*fn) (void *,void*,hargtype_t,unsigned,hargkey_t*),
  1115.    void *state)
  1116. {
  1117.   do_for_all_cb_state s ;
  1118.   if (a == 0) {
  1119.     errno = EINVAL; 
  1120.     return -1; 
  1121.   }
  1123.   s.state = state ;
  1124.   if ((s.cb_fn = fn) == 0) 
  1125.     return -1 ;
  1127.   
  1128.   return for_hlst_do 
  1129.     (a->x, (int(*)(void*,void*,char*,unsigned))do_for_all_cb, &s);
  1130. }
  1133. void
  1134. harg_dump
  1135.   (harglst *a)
  1136. {
  1137.   if (a == 0) return ;
  1138.   do_harg_dump (a, 0);
  1139.   /* hlst_statistics (a->x, 0, 0); not tested, yet */
  1140. }
  1142. void
  1143. harg_tracker_flush
  1144.   (void)
  1145. {
  1146. # ifdef HARG_LIST_TRACKER
  1147.   destroy_hlst (harg_tracker);
  1148.   harg_tracker = 0;
  1149. # endif
  1150. }
  1152. void
  1153. harg_tracker_dump
  1154.   (void)
  1155. {
  1156. # ifdef HARG_LIST_TRACKER
  1157.   void **R;
  1158.   int i = 0;
  1159.   sort_hlst (harg_tracker);
  1160.   while (R = inx_hlst (harg_tracker, i++))
  1161.     if (*R != 0) {
  1162.       fprintf (stderr, "{0x%lx} = ", (long)*R);
  1163.       do_harg_dump (*R, 0);
  1164. #     ifdef _WIN32
  1165.       fputc ('r', stderr);
  1166. #     endif 
  1167.       fputc ('n', stderr);
  1168.     }
  1169. # endif
  1170. }
  1172. void /* define a logger function */
  1173.   (*harg_logger(void(*f)(const char *, ...)))
  1174.      (const char *, ...)
  1175. {
  1176.   void (*g) (const char *, ...) ;
  1177.   g = xlog ;
  1178.   xlog = f ;
  1179.   return g ;
  1180. }
  1182. int
  1183. harg_debuglevel
  1184.   (int n)
  1185. {
  1186.   unsigned d = -1;
  1187.   IFDEBUG (d = dbglevel) ;
  1188.   IFDEBUG (dbglevel = n);
  1189.   return d;
  1190. }
  1192. /* ------------------------------------------------------------------------- *
  1193.  *                 source ends here                                          *
  1194.  * ------------------------------------------------------------------------- */