git.sur5r.net Git - openldap/blob - servers/slapd/charray.c

   1 /* charray.c - routines for dealing with char * arrays */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/string.h>
  13 #include <ac/socket.h>
  14
  15 #include "slap.h"
  16
  17 void
  18 charray_add(
  19     char        ***a,
  20     const char  *s
  21 )
  22 {
  23         int     n;
  24
  25         if ( *a == NULL ) {
  26                 *a = (char **) ch_malloc( 2 * sizeof(char *) );
  27                 n = 0;
  28         } else {
  29                 for ( n = 0; *a != NULL && (*a)[n] != NULL; n++ ) {
  30                         ;       /* NULL */
  31                 }
  32
  33                 *a = (char **) ch_realloc( (char *) *a,
  34                     (n + 2) * sizeof(char *) );
  35         }
  36
  37         (*a)[n++] = ch_strdup(s);
  38         (*a)[n] = NULL;
  39 }
  40
  41 void
  42 charray_add_n(
  43     char        ***a,
  44     const char  *s,
  45     int         l
  46 )
  47 {
  48         int     n;
  49
  50         if ( *a == NULL ) {
  51                 *a = (char **) ch_malloc( 2 * sizeof(char *) );
  52                 n = 0;
  53         } else {
  54                 for ( n = 0; *a != NULL && (*a)[n] != NULL; n++ ) {
  55                         ;       /* NULL */
  56                 }
  57
  58                 *a = (char **) ch_realloc( (char *) *a,
  59                     (n + 2) * sizeof(char *) );
  60         }
  61
  62         (*a)[n] = (char *) ch_malloc( ( l + 1 ) * sizeof( char ) );
  63         strncpy( (*a)[n], s, l );
  64         (*a)[n][l] = '\0';
  65         (*a)[++n] = NULL;
  66 }
  67
  68 void
  69 charray_merge(
  70     char        ***a,
  71     char        **s
  72 )
  73 {
  74         int     i, n, nn;
  75
  76         for ( n = 0; *a != NULL && (*a)[n] != NULL; n++ ) {
  77                 ;       /* NULL */
  78         }
  79         for ( nn = 0; s[nn] != NULL; nn++ ) {
  80                 ;       /* NULL */
  81         }
  82
  83         *a = (char **) ch_realloc( (char *) *a, (n + nn + 1) * sizeof(char *) );
  84
  85         for ( i = 0; i < nn; i++ ) {
  86                 (*a)[n + i] = ch_strdup(s[i]);
  87         }
  88         (*a)[n + nn] = NULL;
  89 }
  90
  91 void
  92 charray_free( char **array )
  93 {
  94         char    **a;
  95
  96         if ( array == NULL ) {
  97                 return;
  98         }
  99
 100         for ( a = array; *a != NULL; a++ ) {
 101                 if ( *a != NULL ) {
 102                         free( *a );
 103                 }
 104         }
 105         free( (char *) array );
 106 }
 107
 108 int
 109 charray_inlist(
 110     char        **a,
 111     const char  *s
 112 )
 113 {
 114         int     i;
 115
 116         if( a == NULL ) return 0;
 117
 118         for ( i = 0; a[i] != NULL; i++ ) {
 119                 if ( strcasecmp( s, a[i] ) == 0 ) {
 120                         return( 1 );
 121                 }
 122         }
 123
 124         return( 0 );
 125 }
 126
 127 char **
 128 charray_dup( char **a )
 129 {
 130         int     i;
 131         char    **new;
 132
 133         for ( i = 0; a[i] != NULL; i++ )
 134                 ;       /* NULL */
 135
 136         new = (char **) ch_malloc( (i + 1) * sizeof(char *) );
 137
 138         for ( i = 0; a[i] != NULL; i++ ) {
 139                 new[i] = ch_strdup( a[i] );
 140         }
 141         new[i] = NULL;
 142
 143         return( new );
 144 }
 145
 146
 147 char **
 148 str2charray( const char *str_in, const char *brkstr )
 149 {
 150         char    *str;
 151         char    **res;
 152         char    *s;
 153         char    *lasts;
 154         int     i;
 155
 156         /* protect the input string from strtok */
 157         str = ch_strdup( str_in );
 158
 159         i = 1;
 160         for ( s = str; *s; s++ ) {
 161                 if ( strchr( brkstr, *s ) != NULL ) {
 162                         i++;
 163                 }
 164         }
 165
 166         res = (char **) ch_malloc( (i + 1) * sizeof(char *) );
 167         i = 0;
 168
 169         for ( s = ldap_pvt_strtok( str, brkstr, &lasts );
 170                 s != NULL;
 171                 s = ldap_pvt_strtok( NULL, brkstr, &lasts ) )
 172         {
 173                 res[i++] = ch_strdup( s );
 174         }
 175
 176         res[i] = NULL;
 177
 178         free( str );
 179         return( res );
 180 }
 181
 182 int
 183 charray_strcmp( const char **a1, const char **a2 )
 184 {
 185         for ( ; a1[0] && a2[0]; a1++, a2++ ) {
 186                 if ( strcmp( a1[0], a2[0] ) ) {
 187                         return( !0 );
 188                 }
 189         }
 190
 191         if ( a1[0] || a2[0] ) {
 192                 return( !0 );
 193         }
 194
 195         return 0;
 196 }
 197
 198
 199 int
 200 charray_strcasecmp( const char **a1, const char **a2 )
 201 {
 202         for ( ; a1[0] && a2[0]; a1++, a2++ ) {
 203                 if ( strcasecmp( a1[0], a2[0] ) ) {
 204                         return( !0 );
 205                 }
 206         }
 207
 208         if ( a1[0] || a2[0] ) {
 209                 return( !0 );
 210         }
 211
 212         return 0;
 213 }
 214
 215 /* strcopy is like strcpy except it returns a pointer to the trailing NUL of
 216  * the result string. This allows fast construction of catenated strings
 217  * without the overhead of strlen/strcat.
 218  */
 219 char *
 220 slap_strcopy(
 221         char *a,
 222         const char *b
 223 )
 224 {
 225         if (!a || !b)
 226                 return a;
 227
 228         while (*a++ = *b++) ;
 229         return a-1;
 230 }
 231
 232 /* strncopy is like strcpy except it returns a pointer to the trailing NUL of
 233  * the result string. This allows fast construction of catenated strings
 234  * without the overhead of strlen/strcat.
 235  */
 236 char *
 237 slap_strncopy(
 238         char *a,
 239         const char *b,
 240         size_t n
 241 )
 242 {
 243         if (!a || !b || n == 0)
 244                 return a;
 245
 246         while ((*a++ = *b++) && n-- > 0) ;
 247         return a-1;
 248 }