This source file includes following definitions.
- set_first_token
- next_token
- toktocliplist
- StrCaseCmp
- StrnCaseCmp
- strequal
- strnequal
- strcsequal
- strlower
- strupper
- strnorm
- strisnormal
- string_replace
- skip_string
- str_charnum
- trim_string
- strhasupper
- strhaslower
- count_chars
- safe_strcpy
- safe_strcat
- StrCpy
- StrnCpy
- strncpyn
- strhex_to_str
- in_list
- string_init
- string_free
- string_set
- string_sub
- all_string_sub
- split_at_last_component
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 #include "includes.h"
28
29 extern int DEBUGLEVEL;
30
31 static char *last_ptr = NULL;
32
33 void
34 set_first_token (char *ptr)
35 {
36 last_ptr = ptr;
37 }
38
39
40
41
42
43
44
45 BOOL
46 next_token (char **ptr, char *buff, const char *sep, size_t bufsize)
47 {
48 char *s;
49 BOOL quoted;
50 size_t len = 1;
51
52 if (!ptr)
53 ptr = &last_ptr;
54 if (!ptr)
55 return (False);
56
57 s = *ptr;
58
59
60 if (!sep)
61 sep = " \t\n\r";
62
63
64 while (*s && strchr (sep, *s))
65 s++;
66
67
68 if (!*s)
69 return (False);
70
71
72 for (quoted = False; len < bufsize && *s && (quoted || !strchr (sep, *s)); s++)
73 {
74 if (*s == '\"')
75 {
76 quoted = !quoted;
77 }
78 else
79 {
80 len++;
81 *buff++ = *s;
82 }
83 }
84
85 *ptr = (*s) ? s + 1 : s;
86 *buff = 0;
87 last_ptr = *ptr;
88
89 return (True);
90 }
91
92 #if 0
93
94
95
96
97 char **
98 toktocliplist (int *ctok, char *sep)
99 {
100 char *s = last_ptr;
101 int ictok = 0;
102 char **ret, **iret;
103
104 if (!sep)
105 sep = " \t\n\r";
106
107 while (*s && strchr (sep, *s))
108 s++;
109
110
111 if (!*s)
112 return (NULL);
113
114 do
115 {
116 ictok++;
117 while (*s && (!strchr (sep, *s)))
118 s++;
119 while (*s && strchr (sep, *s))
120 *s++ = 0;
121 }
122 while (*s);
123
124 *ctok = ictok;
125 s = last_ptr;
126
127 if (!(ret = iret = malloc (ictok * sizeof (char *))))
128 return NULL;
129
130 while (ictok--)
131 {
132 *iret++ = s;
133 while (*s++);
134 while (!*s)
135 s++;
136 }
137
138 return ret;
139 }
140 #endif
141
142
143
144
145 int
146 StrCaseCmp (const char *s, const char *t)
147 {
148
149
150
151
152 #if !defined(KANJI_WIN95_COMPATIBILITY)
153
154
155
156
157
158
159
160
161
162 if (lp_client_code_page () == KANJI_CODEPAGE)
163 {
164
165 int diff;
166 for (;;)
167 {
168 if (!*s || !*t)
169 return toupper (*s) - toupper (*t);
170 else if (is_sj_alph (*s) && is_sj_alph (*t))
171 {
172 diff = sj_toupper2 (*(s + 1)) - sj_toupper2 (*(t + 1));
173 if (diff)
174 return diff;
175 s += 2;
176 t += 2;
177 }
178 else if (is_shift_jis (*s) && is_shift_jis (*t))
179 {
180 diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
181 if (diff)
182 return diff;
183 diff = ((int) (unsigned char) *(s + 1)) - ((int) (unsigned char) *(t + 1));
184 if (diff)
185 return diff;
186 s += 2;
187 t += 2;
188 }
189 else if (is_shift_jis (*s))
190 return 1;
191 else if (is_shift_jis (*t))
192 return -1;
193 else
194 {
195 diff = toupper (*s) - toupper (*t);
196 if (diff)
197 return diff;
198 s++;
199 t++;
200 }
201 }
202 }
203 else
204 #endif
205 {
206 while (*s && *t && toupper (*s) == toupper (*t))
207 {
208 s++;
209 t++;
210 }
211
212 return (toupper (*s) - toupper (*t));
213 }
214 }
215
216
217
218
219 int
220 StrnCaseCmp (const char *s, const char *t, size_t n)
221 {
222
223
224
225
226 #if !defined(KANJI_WIN95_COMPATIBILITY)
227
228
229
230
231
232
233
234
235
236 if (lp_client_code_page () == KANJI_CODEPAGE)
237 {
238
239 int diff;
240 for (; n > 0;)
241 {
242 if (!*s || !*t)
243 return toupper (*s) - toupper (*t);
244 else if (is_sj_alph (*s) && is_sj_alph (*t))
245 {
246 diff = sj_toupper2 (*(s + 1)) - sj_toupper2 (*(t + 1));
247 if (diff)
248 return diff;
249 s += 2;
250 t += 2;
251 n -= 2;
252 }
253 else if (is_shift_jis (*s) && is_shift_jis (*t))
254 {
255 diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
256 if (diff)
257 return diff;
258 diff = ((int) (unsigned char) *(s + 1)) - ((int) (unsigned char) *(t + 1));
259 if (diff)
260 return diff;
261 s += 2;
262 t += 2;
263 n -= 2;
264 }
265 else if (is_shift_jis (*s))
266 return 1;
267 else if (is_shift_jis (*t))
268 return -1;
269 else
270 {
271 diff = toupper (*s) - toupper (*t);
272 if (diff)
273 return diff;
274 s++;
275 t++;
276 n--;
277 }
278 }
279 return 0;
280 }
281 else
282 #endif
283 {
284 while (n && *s && *t && toupper (*s) == toupper (*t))
285 {
286 s++;
287 t++;
288 n--;
289 }
290
291
292 if (n)
293 return (toupper (*s) - toupper (*t));
294
295
296
297 return (0);
298 }
299 }
300
301
302
303
304 BOOL
305 strequal (const char *s1, const char *s2)
306 {
307 if (s1 == s2)
308 return (True);
309 if (!s1 || !s2)
310 return (False);
311
312 return (StrCaseCmp (s1, s2) == 0);
313 }
314
315
316
317
318 BOOL
319 strnequal (const char *s1, const char *s2, size_t n)
320 {
321 if (s1 == s2)
322 return (True);
323 if (!s1 || !s2 || !n)
324 return (False);
325
326 return (StrnCaseCmp (s1, s2, n) == 0);
327 }
328
329
330
331
332 BOOL
333 strcsequal (const char *s1, const char *s2)
334 {
335 if (s1 == s2)
336 return (True);
337 if (!s1 || !s2)
338 return (False);
339
340 return (strcmp (s1, s2) == 0);
341 }
342
343
344
345
346
347 void
348 strlower (char *s)
349 {
350 while (*s)
351 {
352 #if !defined(KANJI_WIN95_COMPATIBILITY)
353
354
355
356
357
358
359
360
361
362 if (lp_client_code_page () == KANJI_CODEPAGE)
363 {
364
365 if (is_shift_jis (*s))
366 {
367 if (is_sj_upper (s[0], s[1]))
368 s[1] = sj_tolower2 (s[1]);
369 s += 2;
370 }
371 else if (is_kana (*s))
372 {
373 s++;
374 }
375 else
376 {
377 if (isupper (*s))
378 *s = tolower (*s);
379 s++;
380 }
381 }
382 else
383 #endif
384 {
385 size_t skip = skip_multibyte_char (*s);
386 if (skip != 0)
387 s += skip;
388 else
389 {
390 if (isupper (*s))
391 *s = tolower (*s);
392 s++;
393 }
394 }
395 }
396 }
397
398
399
400
401 void
402 strupper (char *s)
403 {
404 while (*s)
405 {
406 #if !defined(KANJI_WIN95_COMPATIBILITY)
407
408
409
410
411
412
413
414
415
416 if (lp_client_code_page () == KANJI_CODEPAGE)
417 {
418
419 if (is_shift_jis (*s))
420 {
421 if (is_sj_lower (s[0], s[1]))
422 s[1] = sj_toupper2 (s[1]);
423 s += 2;
424 }
425 else if (is_kana (*s))
426 {
427 s++;
428 }
429 else
430 {
431 if (islower (*s))
432 *s = toupper (*s);
433 s++;
434 }
435 }
436 else
437 #endif
438 {
439 size_t skip = skip_multibyte_char (*s);
440 if (skip != 0)
441 s += skip;
442 else
443 {
444 if (islower (*s))
445 *s = toupper (*s);
446 s++;
447 }
448 }
449 }
450 }
451
452 #if 0
453
454
455
456 void
457 strnorm (char *s)
458 {
459 extern int case_default;
460 if (case_default == CASE_UPPER)
461 strupper (s);
462 else
463 strlower (s);
464 }
465
466
467
468
469 BOOL
470 strisnormal (char *s)
471 {
472 extern int case_default;
473 if (case_default == CASE_UPPER)
474 return (!strhaslower (s));
475
476 return (!strhasupper (s));
477 }
478 #endif
479
480
481
482
483 void
484 string_replace (char *s, char oldc, char newc)
485 {
486 size_t skip;
487 while (*s)
488 {
489 skip = skip_multibyte_char (*s);
490 if (skip != 0)
491 s += skip;
492 else
493 {
494 if (oldc == *s)
495 *s = newc;
496 s++;
497 }
498 }
499 }
500
501
502
503
504
505 char *
506 skip_string (char *buf, size_t n)
507 {
508 while (n--)
509 buf += strlen (buf) + 1;
510 return (buf);
511 }
512
513
514
515
516
517
518
519
520 size_t
521 str_charnum (const char *s)
522 {
523 size_t len = 0;
524
525 while (*s != '\0')
526 {
527 int skip = skip_multibyte_char (*s);
528 s += (skip ? skip : 1);
529 len++;
530 }
531 return len;
532 }
533
534
535
536
537
538 BOOL
539 trim_string (char *s, const char *front, const char *back)
540 {
541 BOOL ret = False;
542 size_t front_len = (front && *front) ? strlen (front) : 0;
543 size_t back_len = (back && *back) ? strlen (back) : 0;
544 size_t s_len;
545
546 while (front_len && strncmp (s, front, front_len) == 0)
547 {
548 char *p = s;
549 ret = True;
550 while (1)
551 {
552 if (!(*p = p[front_len]))
553 break;
554 p++;
555 }
556 }
557
558
559
560
561
562
563
564
565
566
567 if (back_len)
568 {
569 if (!is_multibyte_codepage ())
570 {
571 s_len = strlen (s);
572 while ((s_len >= back_len) && (strncmp (s + s_len - back_len, back, back_len) == 0))
573 {
574 ret = True;
575 s[s_len - back_len] = '\0';
576 s_len = strlen (s);
577 }
578 }
579 else
580 {
581
582
583
584
585
586
587
588
589
590
591
592
593
594 size_t mb_back_len = str_charnum (back);
595 size_t mb_s_len = str_charnum (s);
596
597 while (mb_s_len >= mb_back_len)
598 {
599 size_t charcount = 0;
600 char *mbp = s;
601
602 while (charcount < (mb_s_len - mb_back_len))
603 {
604 size_t skip = skip_multibyte_char (*mbp);
605 mbp += (skip ? skip : 1);
606 charcount++;
607 }
608
609
610
611
612
613
614 if (strcmp (mbp, back) == 0)
615 {
616 ret = True;
617 *mbp = '\0';
618 mb_s_len = str_charnum (s);
619 mbp = s;
620 }
621 else
622 break;
623 }
624 }
625 }
626
627 return (ret);
628 }
629
630 #if 0
631
632
633
634 BOOL
635 strhasupper (const char *s)
636 {
637 while (*s)
638 {
639 #if !defined(KANJI_WIN95_COMPATIBILITY)
640
641
642
643
644
645
646
647
648
649 if (lp_client_code_page () == KANJI_CODEPAGE)
650 {
651
652 if (is_shift_jis (*s))
653 s += 2;
654 else if (is_kana (*s))
655 s++;
656 else
657 {
658 if (isupper (*s))
659 return (True);
660 s++;
661 }
662 }
663 else
664 #endif
665 {
666 size_t skip = skip_multibyte_char (*s);
667 if (skip != 0)
668 s += skip;
669 else
670 {
671 if (isupper (*s))
672 return (True);
673 s++;
674 }
675 }
676 }
677 return (False);
678 }
679
680
681
682
683
684 BOOL
685 strhaslower (const char *s)
686 {
687 while (*s)
688 {
689 #if !defined(KANJI_WIN95_COMPATIBILITY)
690
691
692
693
694
695
696
697
698
699 if (lp_client_code_page () == KANJI_CODEPAGE)
700 {
701
702 if (is_shift_jis (*s))
703 {
704 if (is_sj_upper (s[0], s[1]))
705 return (True);
706 if (is_sj_lower (s[0], s[1]))
707 return (True);
708 s += 2;
709 }
710 else if (is_kana (*s))
711 {
712 s++;
713 }
714 else
715 {
716 if (islower (*s))
717 return (True);
718 s++;
719 }
720 }
721 else
722 #endif
723 {
724 size_t skip = skip_multibyte_char (*s);
725 if (skip != 0)
726 s += skip;
727 else
728 {
729 if (islower (*s))
730 return (True);
731 s++;
732 }
733 }
734 }
735 return (False);
736 }
737 #endif
738
739
740
741
742 size_t
743 count_chars (const char *s, char c)
744 {
745 size_t count = 0;
746
747 #if !defined(KANJI_WIN95_COMPATIBILITY)
748
749
750
751
752
753
754
755
756
757 if (lp_client_code_page () == KANJI_CODEPAGE)
758 {
759
760 while (*s)
761 {
762 if (is_shift_jis (*s))
763 s += 2;
764 else
765 {
766 if (*s == c)
767 count++;
768 s++;
769 }
770 }
771 }
772 else
773 #endif
774 {
775 while (*s)
776 {
777 size_t skip = skip_multibyte_char (*s);
778 if (skip != 0)
779 s += skip;
780 else
781 {
782 if (*s == c)
783 count++;
784 s++;
785 }
786 }
787 }
788 return (count);
789 }
790
791
792
793
794
795
796
797 char *
798 safe_strcpy (char *dest, const char *src, size_t maxlength)
799 {
800 size_t len;
801
802 if (!dest)
803 {
804 DEBUG (0, ("ERROR: NULL dest in safe_strcpy\n"));
805 return NULL;
806 }
807
808 if (!src)
809 {
810 *dest = 0;
811 return dest;
812 }
813
814 len = strlen (src);
815
816 if (len > maxlength)
817 {
818 DEBUG (0, ("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
819 (int) (len - maxlength), src));
820 len = maxlength;
821 }
822
823 memcpy (dest, src, len);
824 dest[len] = 0;
825 return dest;
826 }
827
828
829
830
831
832 char *
833 safe_strcat (char *dest, const char *src, size_t maxlength)
834 {
835 size_t src_len, dest_len;
836
837 if (!dest)
838 {
839 DEBUG (0, ("ERROR: NULL dest in safe_strcat\n"));
840 return NULL;
841 }
842
843 if (!src)
844 {
845 return dest;
846 }
847
848 src_len = strlen (src);
849 dest_len = strlen (dest);
850
851 if (src_len + dest_len > maxlength)
852 {
853 DEBUG (0, ("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
854 (int) (src_len + dest_len - maxlength), src));
855 src_len = maxlength - dest_len;
856 }
857
858 memcpy (&dest[dest_len], src, src_len);
859 dest[dest_len + src_len] = 0;
860 return dest;
861 }
862
863
864
865
866 char *
867 StrCpy (char *dest, const char *src)
868 {
869 char *d = dest;
870
871
872 SMB_ASSERT (dest && src);
873
874 if (!dest)
875 return (NULL);
876 if (!src)
877 {
878 *dest = 0;
879 return (dest);
880 }
881 while ((*d++ = *src++));
882 return (dest);
883 }
884
885
886
887
888 char *
889 StrnCpy (char *dest, const char *src, size_t n)
890 {
891 char *d = dest;
892 if (!dest)
893 return (NULL);
894 if (!src)
895 {
896 *dest = 0;
897 return (dest);
898 }
899 while (n-- && (*d++ = *src++));
900 *d = 0;
901 return (dest);
902 }
903
904 #if 0
905
906
907
908
909 char *
910 strncpyn (char *dest, const char *src, size_t n, char c)
911 {
912 char *p;
913 size_t str_len;
914
915 p = strchr (src, c);
916 if (p == NULL)
917 {
918 DEBUG (5, ("strncpyn: separator character (%c) not found\n", c));
919 return NULL;
920 }
921
922 str_len = PTR_DIFF (p, src);
923 strncpy (dest, src, MIN (n, str_len));
924 dest[str_len] = '\0';
925
926 return p;
927 }
928
929
930
931
932
933
934
935
936
937
938
939 size_t
940 strhex_to_str (char *p, size_t len, const char *strhex)
941 {
942 size_t i;
943 size_t num_chars = 0;
944 unsigned char lonybble, hinybble;
945 char *hexchars = "0123456789ABCDEF";
946 char *p1 = NULL, *p2 = NULL;
947
948 for (i = 0; i < len && strhex[i] != 0; i++)
949 {
950 if (strnequal (hexchars, "0x", 2))
951 {
952 i++;
953 continue;
954 }
955
956 if (!(p1 = strchr (hexchars, toupper (strhex[i]))))
957 {
958 break;
959 }
960
961 i++;
962
963 if (!(p2 = strchr (hexchars, toupper (strhex[i]))))
964 {
965 break;
966 }
967
968
969 hinybble = PTR_DIFF (p1, hexchars);
970 lonybble = PTR_DIFF (p2, hexchars);
971
972 p[num_chars] = (hinybble << 4) | lonybble;
973 num_chars++;
974
975 p1 = NULL;
976 p2 = NULL;
977 }
978 return num_chars;
979 }
980
981
982
983
984 BOOL
985 in_list (char *s, char *list, BOOL casesensitive)
986 {
987 pstring tok;
988 char *p = list;
989
990 if (!list)
991 return (False);
992
993 while (next_token (&p, tok, LIST_SEP, sizeof (tok)))
994 {
995 if (casesensitive)
996 {
997 if (strcmp (tok, s) == 0)
998 return (True);
999 }
1000 else
1001 {
1002 if (StrCaseCmp (tok, s) == 0)
1003 return (True);
1004 }
1005 }
1006 return (False);
1007 }
1008 #endif
1009
1010
1011 static char *null_string = NULL;
1012
1013
1014
1015
1016 BOOL
1017 string_init (char **dest, const char *src)
1018 {
1019 size_t l;
1020 if (!src)
1021 src = "";
1022
1023 l = strlen (src);
1024
1025 if (l == 0)
1026 {
1027 if (!null_string)
1028 {
1029 if ((null_string = (char *) malloc (1)) == NULL)
1030 {
1031 DEBUG (0, ("string_init: malloc fail for null_string.\n"));
1032 return False;
1033 }
1034 *null_string = 0;
1035 }
1036 *dest = null_string;
1037 }
1038 else
1039 {
1040 (*dest) = (char *) malloc (l + 1);
1041 if ((*dest) == NULL)
1042 {
1043 DEBUG (0, ("Out of memory in string_init\n"));
1044 return False;
1045 }
1046
1047 pstrcpy (*dest, src);
1048 }
1049 return (True);
1050 }
1051
1052
1053
1054
1055 void
1056 string_free (char **s)
1057 {
1058 if (!s || !(*s))
1059 return;
1060 if (*s == null_string)
1061 *s = NULL;
1062 if (*s)
1063 free (*s);
1064 *s = NULL;
1065 }
1066
1067
1068
1069
1070
1071 BOOL
1072 string_set (char **dest, const char *src)
1073 {
1074 string_free (dest);
1075
1076 return (string_init (dest, src));
1077 }
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089 void
1090 string_sub (char *s, const char *pattern, const char *insert)
1091 {
1092 char *p;
1093 size_t ls, lp, li, i;
1094
1095 if (!insert || !pattern || !s)
1096 return;
1097
1098 ls = strlen (s);
1099 lp = strlen (pattern);
1100 li = strlen (insert);
1101
1102 if (!*pattern)
1103 return;
1104
1105 while (lp <= ls && (p = strstr (s, pattern)))
1106 {
1107 memmove (p + li, p + lp, ls + 1 - (PTR_DIFF (p, s) + lp));
1108 for (i = 0; i < li; i++)
1109 {
1110 switch (insert[i])
1111 {
1112 case '`':
1113 case '"':
1114 case '\'':
1115 case ';':
1116 p[i] = '_';
1117 break;
1118 default:
1119 p[i] = insert[i];
1120 }
1121 }
1122 s = p + li;
1123 ls += (li - lp);
1124 }
1125 }
1126
1127 #if 0
1128
1129
1130
1131
1132 void
1133 all_string_sub (char *s, const char *pattern, const char *insert)
1134 {
1135 char *p;
1136 size_t ls, lp, li;
1137
1138 if (!insert || !pattern || !s)
1139 return;
1140
1141 ls = strlen (s);
1142 lp = strlen (pattern);
1143 li = strlen (insert);
1144
1145 if (!*pattern)
1146 return;
1147
1148 while (lp <= ls && (p = strstr (s, pattern)))
1149 {
1150 memmove (p + li, p + lp, ls + 1 - (PTR_DIFF (p, s) + lp));
1151 memcpy (p, insert, li);
1152 s = p + li;
1153 ls += (li - lp);
1154 }
1155 }
1156
1157
1158
1159
1160
1161 void
1162 split_at_last_component (char *path, char *front, char sep, char *back)
1163 {
1164 char *p = strrchr (path, sep);
1165
1166 if (p != NULL)
1167 {
1168 *p = 0;
1169 }
1170 if (front != NULL)
1171 {
1172 pstrcpy (front, path);
1173 }
1174 if (p != NULL)
1175 {
1176 if (back != NULL)
1177 {
1178 pstrcpy (back, p + 1);
1179 }
1180 *p = '\\';
1181 }
1182 else
1183 {
1184 if (back != NULL)
1185 {
1186 back[0] = 0;
1187 }
1188 }
1189 }
1190 #endif