]>
jfr.im git - solanum.git/blob - librb/src/tools.c
2 * ircd-ratbox: A slightly useful ircd.
3 * tools.c: Various functions needed here and there.
5 * Copyright (C) 1996-2002 Hybrid Development Team
6 * Copyright (C) 2002-2005 ircd-ratbox development team
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program 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
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
24 * Here is the original header:
26 * Useful stuff, ripped from places ..
27 * adrian chadd <adrian@creative.net.au>
29 * The TOOLS_C define builds versions of the functions in tools.h
30 * so that they end up in the resulting object files. If its not
31 * defined, tools.h will build inlined versions of the functions
32 * on supported compilers
36 #include <librb_config.h>
45 static rb_bh
*dnode_heap
;
47 rb_init_rb_dlink_nodes(size_t dh_size
)
50 dnode_heap
= rb_bh_create(sizeof(rb_dlink_node
), dh_size
, "librb_dnode_heap");
51 if(dnode_heap
== NULL
)
59 * output - pointer to new rb_dlink_node
63 rb_make_rb_dlink_node(void)
65 return (rb_bh_alloc(dnode_heap
));
71 * inputs - pointer to rb_dlink_node
73 * side effects - free given rb_dlink_node
76 rb_free_rb_dlink_node(rb_dlink_node
*ptr
)
79 rb_bh_free(dnode_heap
, ptr
);
82 /* rb_string_to_array()
83 * Changes a given buffer into an array of parameters.
84 * Taken from ircd-ratbox.
86 * inputs - string to parse, array to put in
87 * outputs - number of parameters
90 rb_string_to_array(char *string
, char **parv
, int maxpara
)
92 char *p
, *xbuf
= string
;
97 if(string
== NULL
|| string
[0] == '\0')
100 while(*xbuf
== ' ') /* skip leading spaces */
102 if(*xbuf
== '\0') /* ignore all-space args */
107 if(*xbuf
== ':') /* Last parameter */
118 if((p
= strchr(xbuf
, ' ')) != NULL
)
131 while(x
< maxpara
- 1);
141 #ifndef HAVE_STRCASECMP
143 /* Crummy fallback impl by me. --Elizafox */
145 rb_strcasecmp(const char *s1
, const char *s2
)
147 for(; *s1
!= '\0' || *s2
!= '\0'; s1
++, s2
++)
149 if(tolower(*s1
) != tolower(*s2
))
150 return tolower(*s1
) - tolower(*s2
);
153 if(*s1
== '\0' && *s2
== '\0')
156 return tolower(*(--s1
)) - tolower(*(--s2
));
160 rb_strcasecmp(const char *s1
, const char *s2
)
162 return stricmp(s1
, s2
);
165 #else /* HAVE_STRCASECMP */
167 rb_strcasecmp(const char *s1
, const char *s2
)
169 return strcasecmp(s1
, s2
);
173 #ifndef HAVE_STRNCASECMP
175 /* Crummy fallback impl by me. --Elizafox */
177 rb_strncasecmp(const char *s1
, const char *s2
, size_t n
)
182 for(; *s1
!= '\0' || *s2
!= '\0' || n
; s1
++, s2
++, n
--)
184 if(tolower(*s1
) != tolower(*s2
))
185 return tolower(*s1
) - tolower(*s2
);
188 if(*s1
== '\0' && *s2
== '\0')
191 return tolower(*(--s1
)) - tolower(*(--s2
));
195 rb_strncasecmp(const char *s1
, const char *s2
, size_t n
)
197 return strnicmp(s1
, s2
, n
);
200 #else /* HAVE_STRNCASECMP */
202 rb_strncasecmp(const char *s1
, const char *s2
, size_t n
)
204 return strncasecmp(s1
, s2
, n
);
208 #ifndef HAVE_STRCASESTR
209 /* Crummy fallback impl by me. --Elizafox */
211 rb_strcasestr(const char *s
, const char *find
)
213 size_t len_f
= strlen(find
);
218 for(char *c
= (char *)s
; *c
!= '\0'; c
++)
220 if(*c
== *find
&& strncasecmp(c
, find
, len_f
) == 0)
228 rb_strcasestr(const char *s
, const char *find
)
230 return strcasestr(s
, find
);
236 rb_strlcat(char *dest
, const char *src
, size_t count
)
238 size_t dsize
= strlen(dest
);
239 size_t len
= strlen(src
);
240 size_t res
= dsize
+ len
;
246 memcpy(dest
, src
, len
);
252 rb_strlcat(char *dest
, const char *src
, size_t count
)
254 return strlcat(dest
, src
, count
);
260 rb_strlcpy(char *dest
, const char *src
, size_t size
)
262 size_t ret
= strlen(src
);
266 size_t len
= (ret
>= size
) ? size
- 1 : ret
;
267 memcpy(dest
, src
, len
);
274 rb_strlcpy(char *dest
, const char *src
, size_t size
)
276 return strlcpy(dest
, src
, size
);
283 rb_strnlen(const char *s
, size_t count
)
286 for(sc
= s
; count
-- && *sc
!= '\0'; ++sc
)
292 rb_strnlen(const char *s
, size_t count
)
294 return strnlen(s
, count
);
299 * rb_snprintf_append()
300 * appends snprintf formatted string to the end of the buffer but not
304 rb_snprintf_append(char *str
, size_t len
, const char *format
, ...)
309 size_t x
= strlen(str
);
318 va_start(ap
, format
);
319 int y
= (vsnprintf(str
+ x
, len
- x
, format
, ap
) + (int)x
);
332 rb_basename(const char *path
)
336 if(!(s
= strrchr(path
, '/')))
348 rb_dirname (const char *path
)
352 s
= strrchr(path
, '/');
355 return rb_strdup(".");
358 /* remove extra slashes */
359 while(s
> path
&& *s
== '/')
362 return rb_strndup(path
, ((uintptr_t)s
- (uintptr_t)path
) + 2);
365 size_t rb_zstring_serialized(rb_zstring_t
*zs
, void **buf
, size_t *buflen
)
368 size_t alloclen
= sizeof(uint16_t) + zs
->len
;
370 p
= rb_malloc(sizeof(alloclen
));
371 memcpy(p
, &zs
->len
, sizeof(uint16_t));
372 p
+= sizeof(uint16_t);
373 memcpy(p
, zs
->data
, zs
->len
);
377 size_t rb_zstring_deserialize(rb_zstring_t
*zs
, void *buf
)
379 uint8_t *p
= (uint8_t *)buf
;
381 memcpy(&zs
->len
, p
, sizeof(uint16_t));
382 p
+= sizeof(uint16_t);
386 return sizeof(uint16_t);
388 zs
->data
= rb_malloc(zs
->len
);
389 memcpy(zs
->data
, p
, zs
->len
);
390 return zs
->len
+ sizeof(uint16_t);
393 void rb_zstring_free(rb_zstring_t
*zs
)
400 rb_zstring_t
*rb_zstring_alloc(void)
402 rb_zstring_t
*zs
= rb_malloc(sizeof(rb_zstring_t
));
406 rb_zstring_t
*rb_zstring_from_c_len(const char *buf
, size_t len
)
410 if(len
> UINT16_MAX
-1)
413 zs
= rb_zstring_alloc();
414 zs
->alloclen
= zs
->len
= (uint16_t)len
;
415 zs
->alloclen
= (uint16_t)len
;
416 if(zs
->alloclen
< 128)
418 zs
->data
= rb_malloc(zs
->alloclen
);
419 memcpy(zs
->data
, buf
, zs
->len
);
423 rb_zstring_t
*rb_zstring_from_c(const char *buf
)
425 return rb_zstring_from_c_len(buf
, strlen(buf
));
428 size_t rb_zstring_len(rb_zstring_t
*zs
)
433 void rb_zstring_append_from_zstring(rb_zstring_t
*dst_zs
, rb_zstring_t
*src_zs
)
436 size_t nlen
= dst_zs
->len
+ src_zs
->len
;
438 if(nlen
> dst_zs
->alloclen
)
440 dst_zs
->alloclen
+= src_zs
->len
+ 64;
441 dst_zs
->data
= rb_realloc(dst_zs
->data
, dst_zs
->alloclen
);
444 ep
= dst_zs
->data
+ dst_zs
->len
;
445 memcpy(ep
, src_zs
->data
, src_zs
->len
);
448 void rb_zstring_append_from_c(rb_zstring_t
*zs
, const char *buf
, size_t len
)
451 size_t nlen
= zs
->len
+ len
;
453 if(nlen
> zs
->alloclen
)
455 zs
->alloclen
+= len
+ 64;
456 zs
->data
= rb_realloc(zs
->data
, zs
->alloclen
);
458 ep
= zs
->data
+ zs
->len
;
460 memcpy(ep
, buf
, len
);
463 char *rb_zstring_to_c(rb_zstring_t
*zs
, char *buf
, size_t len
)
471 memcpy(buf
, zs
->data
, cpylen
);
476 char *rb_zstring_to_c_alloc(rb_zstring_t
*zs
)
479 p
= rb_malloc(zs
->len
+1);
480 memcpy(p
, zs
->data
, zs
->len
);
484 size_t rb_zstring_to_ptr(rb_zstring_t
*zs
, void **ptr
)
486 *ptr
= (void *)zs
->data
;