zuluCrypt  5.7.1
About: zuluCrypt is a simple but feature rich solution for hard drives encryption. It can manage PLAIN dm-crypt, LUKS, TrueCrypt and VeraCrypt encrypted volumes.
  Fossies Dox: zuluCrypt-5.7.1.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

String.c
Go to the documentation of this file.
1 /*
2  *
3  * Copyright (c) 2011-2015
4  * name : Francis Banyikwa
5  * email: mhogomchungu@gmail.com
6  * This program is free software: you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation, either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
18  */
19 
20 #include "String.h"
21 
22 #ifndef _GNU_SOURCE
23 #define _GNU_SOURCE
24 #endif
25 
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <stdio.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <fcntl.h>
32 #include <unistd.h>
33 #include <stdarg.h>
34 #include <termios.h>
35 #include <sys/mman.h>
36 
37 #define ignore_result( x ) if( x ){;}
38 
39 /*
40  * a string memory block gows by below factor when it expands
41  */
42 #define FACTOR 2
43 
44 /*
45  * when an empty string is initialized,star it with below buffer size
46  */
47 #define STRING_INIT_SIZE 32
48 
49 struct StringType
50 {
51  /*
52  * pointer to the string
53  */
54  char * string ;
55  /*
56  *the size of the string
57  */
58  size_t size ;
59  /*
60  * the size of the string buffer
61  */
62  size_t length ;
63  /*
64  * contains info if the string is owned by stringlist
65  */
66  int owned ;
67 };
68 
69 static void _f( void )
70 {
71 }
72 
73 static void ( *_memory_error )( void ) = _f ;
74 
75 void StringExitOnMemoryExaustion( void ( *f )( void ) )
76 {
77  _memory_error = f ;
78 }
79 
80 static void * _StringError( void )
81 {
82  _memory_error() ;
83  return NULL ;
84 }
85 
87 {
88  if( st == StringVoid ){
89  return 0 ;
90  }else{
91  return st->owned ;
92  }
93 }
94 
95 const char * StringToLowerCase( string_t st )
96 {
97  char * it ;
98  const char * end ;
99 
100  if( st == StringVoid ){
101  return NULL ;
102  }else{
103  end = st->string + st->size ;
104 
105  for( it = st->string ; it != end ; it++ ){
106 
107  if( *it >= 'A' && *it <= 'Z' ){
108 
109  *it += 32 ;
110  }
111  }
112 
113  return st->string ;
114  }
115 }
116 
117 static inline char * __StringExpandMemory( string_t st,size_t new_size )
118 {
119  char * p ;
120  if( new_size >= st->length ){
121  st->length = new_size * FACTOR ;
122  p = realloc( st->string,st->length ) ;
123  if( p == NULL ){
124  return _StringError() ;
125  }else{
126  return p ;
127  }
128  }else{
129  return st->string ;
130  }
131 }
132 
134 {
135  if( st == StringVoid ){
136  *begin = NULL ;
137  *end = NULL ;
138  }else{
139  *begin = st->string ;
140  *end = st->string + st->size ;
141  }
142 }
143 
145 {
146  if( st != StringVoid ){
147  return mlock( st->string,st->size ) ;
148  }else{
149  return -1 ;
150  }
151 }
152 
154 {
155  if( st != StringVoid ){
156  return munlock( st->string,st->size ) ;
157  }else{
158  return -1 ;
159  }
160 }
161 
162 void StringDelete( string_t * st )
163 {
164  string_t s ;
165  if( st != NULL ){
166  s = *st ;
167  if( s != StringVoid ){
168  if( s->owned == 0 ){
169  *st = StringVoid ;
170  free( s->string ) ;
171  free( s ) ;
172  }
173  }
174  }
175 }
176 
178 {
179  string_t s ;
180  char * e ;
181  if( st != NULL ){
182  s = *st ;
183  if( s != StringVoid ){
184  if( s->owned == 0 ){
185  *st = StringVoid ;
186  e = s->string ;
187  memset( e,'\0',s->length ) ;
188  free( e ) ;
189  free( s ) ;
190  }
191  }
192  }
193 }
194 
196 {
197  string_t * entry ;
198  va_list list ;
199  string_t st ;
200 
201  if( xt == NULL ){
202  return ;
203  }
204  st = *xt ;
205  if( st != StringVoid ){
206  if( st->owned == 0 ){
207  free( st->string ) ;
208  free( st ) ;
209  *xt = StringVoid ;
210  }
211  }
212 
213  va_start( list,xt ) ;
214 
215  while( 1 ){
216  entry = va_arg( list,string_t * ) ;
217  if( entry == NULL ){
218  break ;
219  }
220  st = *entry ;
221  if( st != StringVoid ){
222  if( st->owned == 0 ){
223  free( st->string ) ;
224  free( st ) ;
225  *entry = StringVoid ;
226  }
227  }
228  }
229 
230  va_end( list ) ;
231 }
232 
234 {
235  char * c = NULL ;
236  string_t st ;
237  if( xt == NULL ){
238  return NULL ;
239  }
240  st = *xt ;
241  if( st == StringVoid ){
242  return NULL ;
243  }
244  if( st->owned == 0 ){
245  *xt = StringVoid ;
246  c = st->string ;
247  free( st ) ;
248  }else{
249  c = malloc( sizeof( char ) * ( st->size + 1 ) ) ;
250  if( c == NULL ){
251  return _StringError() ;
252  }else{
253  memcpy( c,st->string,st->size + 1 ) ;
254  }
255  }
256 
257  return c ;
258 }
259 
261 {
262  string_t xt ;
263  char * c ;
264 
265  if( st == StringVoid ){
266  return StringVoid ;
267  }
268 
269  c = malloc( sizeof( char ) * ( st->size + 1 ) ) ;
270 
271  if( c == NULL ){
272  return _StringError() ;
273  }
274 
275  xt = malloc( sizeof( struct StringType ) ) ;
276 
277  if( xt == NULL ){
278  free( c ) ;
279  return _StringError() ;
280  }else{
281  memcpy( c,st->string,st->size + 1 ) ;
282 
283  xt->size = st->size ;
284  xt->length = st->size + 1 ;
285  xt->string = c ;
286  xt->owned = 0 ;
287 
288  return xt ;
289  }
290 }
291 
293 {
294  return StringBuffer( 8 ) ;
295 }
296 
298 {
299  string_t st = ( string_t ) malloc( sizeof( struct StringType ) ) ;
300 
301  if( st == NULL ){
302  return _StringError() ;
303  }else{
304  st->string = malloc( s * sizeof( char ) ) ;
305  if( st->string == NULL ){
306  free( st ) ;
307  return _StringError() ;
308  }else{
309  st->string[ 0 ] = '\0' ;
310  st->size = 0 ;
311  st->owned = 0 ;
312  st->length = s ;
313  return st ;
314  }
315  }
316 }
317 
318 string_t String( const char * cstring )
319 {
320  size_t size ;
321  string_t st ;
322 
323  if( cstring == NULL ){
324  return StringVoid ;
325  }
326 
327  size = strlen( cstring ) ;
328 
329  st = malloc( sizeof( struct StringType ) ) ;
330 
331  if( st == NULL ){
332  return _StringError() ;
333  }
334  if( size < STRING_INIT_SIZE / 2 ){
335 
336  st->string = malloc( sizeof( char ) * STRING_INIT_SIZE ) ;
337  if( st->string == NULL ){
338  free( st ) ;
339  return _StringError() ;
340  }else{
341  memcpy( st->string,cstring,size + 1 ) ;
342  st->size = size ;
343  st->length = STRING_INIT_SIZE ;
344  st->owned = 0 ;
345  return st ;
346  }
347  }else{
348  st->string = malloc( sizeof( char ) * ( size + 1 ) );
349 
350  if( st->string == NULL ){
351  free( st ) ;
352  return _StringError() ;
353  }else{
354  memcpy( st->string,cstring,size + 1 ) ;
355  st->size = size ;
356  st->length = size + 1 ;
357  st->owned = 0 ;
358  return st ;
359  }
360  }
361 }
362 
363 string_t String_1( const char * cstring,... )
364 {
365  string_t st = String( cstring ) ;
366 
367  const char * entry ;
368  va_list list ;
369  va_start( list,cstring ) ;
370 
371  while( 1 ){
372  entry = va_arg( list,const char * ) ;
373  if( entry == NULL ){
374  break ;
375  }
376  StringAppend( st,entry ) ;
377  }
378 
379  va_end( list ) ;
380 
381  return st ;
382 }
383 
384 void StringReadToBuffer( string_t st,char * buffer,size_t size )
385 {
386  if( buffer != NULL ){
387  memcpy( buffer,st->string,size ) ;
388  }
389 }
390 
391 string_t StringInherit( char ** data )
392 {
393  size_t l ;
394  if( data != NULL ){
395  if( *data != NULL ){
396  l = strlen( *data ) ;
397  return StringInheritWithSize( data,l,l + 1 ) ;
398  }else{
399  return StringVoid ;
400  }
401  }else{
402  return StringVoid ;
403  }
404 }
405 
407 {
408  if( st != StringVoid ){
409  printf( "%s",st->string ) ;
410  }
411 }
412 
414 {
415  if( st != StringVoid ){
416  printf( "%s\n",st->string ) ;
417  }
418 }
419 
420 int StringContains( string_t st,const char * str )
421 {
422  if( st == StringVoid || str == NULL ){
423  return 0 ;
424  }else{
425  return strstr( st->string,str ) != NULL ;
426  }
427 }
428 
429 string_t StringInheritWithSize( char ** data,size_t size,size_t length )
430 {
431  string_t st ;
432 
433  if( data == NULL || *data == NULL ){
434  return StringVoid ;
435  }
436  if( length == 0 ){
437  return StringVoid ;
438  }
439 
440  st = malloc( sizeof( struct StringType ) ) ;
441 
442  if( st == NULL ){
443  return _StringError() ;
444  }
445  st->owned = 0 ;
446  st->size = size ;
447  st->length = length ;
448  st->string = *data ;
449  *data = NULL ;
450  return st ;
451 }
452 
453 string_t StringWithSize( const char * s,size_t len )
454 {
455  char * c ;
456  if( s == NULL ){
457  return StringVoid ;
458  }
459  c = malloc( sizeof( char ) * ( len + 1 ) ) ;
460  if( c == NULL ){
461  return _StringError() ;
462  }
463  memcpy( c,s,len ) ;
464  *( c + len ) = '\0' ;
465  return StringInheritWithSize( &c,len,len + 1 ) ;
466 }
467 
468 ssize_t StringIndexOfString( string_t st,size_t p,const char * s )
469 {
470  char * c ;
471 
472  if( st == StringVoid || s == NULL ){
473  return -1 ;
474  }
475  if( p >= st->size ){
476  return -1 ;
477  }
478 
479  c = strstr( st->string + p,s ) ;
480 
481  if( c == NULL ){
482  return -1 ;
483  }else{
484  return c - st->string ;
485  }
486 }
487 
488 ssize_t StringLastIndexOfChar( string_t st,char s )
489 {
490  char * c ;
491  char * d ;
492 
493  if( st == StringVoid ){
494  return -1 ;
495  }
496 
497  d = st->string ;
498  c = d + st->size ;
499 
500  while( --c != d ){
501  if( *c == s ){
502  return c - d ;
503  }
504  }
505 
506  return -1 ;
507 }
508 
509 ssize_t StringLastIndexOfString( string_t st,const char * s )
510 {
511  ssize_t p = -1 ;
512 
513  char * c ;
514  char * d ;
515  char * e ;
516 
517  size_t len ;
518 
519  if( s == NULL ){
520  return -1 ;
521  }
522 
523  if( st == StringVoid ){
524  return -1 ;
525  }
526 
527  len = strlen( s ) ;
528 
529  if( len == 0 ){
530  return -1 ;
531  }
532 
533  e = d = st->string ;
534 
535  while( 1 )
536  {
537  c = strstr( d,s ) ;
538  if( c != NULL ){
539  p = c - e ;
540  d = d + len ;
541  }else{
542  break ;
543  }
544  }
545  return p ;
546 }
547 
548 ssize_t StringIndexOfChar( string_t st,size_t p,char s )
549 {
550  char * c ;
551  char d[ 2 ] ;
552  *( d + 1 ) = '\0' ;
553  *( d + 0 ) = s ;
554 
555  if( st == StringVoid ){
556  return -1 ;
557  }
558 
559  c = strstr( st->string + p,d ) ;
560 
561  if( c == NULL ){
562  return -1 ;
563  }else{
564  return c - st->string ;
565  }
566 }
567 
568 const char * StringRemoveLength( string_t st,size_t x ,size_t y )
569 {
570  if( st == StringVoid ){
571  return NULL ;
572  }
573  if( x >= st->size ){
574  return st->string ;
575  }
576  if( x + y >= st->size ){
577  y = st->size - x ;
578  }
579 
580  memmove( st->string + x,st->string + x + y,st->size - y - x + 1 ) ;
581 
582  st->size -= y ;
583 
584  return st->string ;
585 }
586 
587 const char * StringRemoveDigits( string_t st )
588 {
589  char * e ;
590  char * f ;
591  char k ;
592  size_t z ;
593 
594  if( st == StringVoid ){
595  return NULL ;
596  }else{
597  z = st->size ;
598  e = st->string ;
599  f = e ;
600  while( 1 ){
601  k = *e ;
602  if( k == '\0' ){
603  break ;
604  }else if( k >= '0' && k <= '9' ){
605  z-- ;
606  f++ ;
607  }else{
608  e++ ;
609  f++ ;
610  }
611  *e = *f ;
612  }
613  st->size = z ;
614  return st->string ;
615  }
616 }
617 
619 {
620  if( st != StringVoid ){
621  memset( st->string,'\0',st->size ) ;
622  st->size = 0 ;
623  }
624 }
625 
627 {
628  if( st != StringVoid ){
629  st->string[ 0 ] = '\0' ;
630  st->size = 0 ;
631  }
632 }
633 
634 const char * StringRemoveRight( string_t st,size_t x )
635 {
636  if( x >= st->size ){
637  st->string[ 0 ] = '\0' ;
638  st->size = 0 ;
639  }else{
640  st->size = st->size - x ;
641  *( st->string + st->size ) = '\0' ;
642  }
643 
644  return st->string ;
645 }
646 
647 const char * StringRemoveLeft( string_t st,size_t x )
648 {
649  return StringRemoveLength( st,0,x ) ;
650 }
651 
652 const char * StringCrop( string_t st,size_t x,size_t y )
653 {
654  ssize_t s ;
655  if( st == StringVoid ){
656  return NULL ;
657  }
658  if( x >= st->size ){
659  x = st->size - 1 ;
660  }
661  if( y >= st->size ){
662  y = st->size - 1 ;
663  }
664 
665  memmove( st->string,st->string + x,st->size - x + 1 ) ;
666 
667  s = st->size - x - y ;
668  if( s < 0 ){
669  st->size = 0 ;
670  }else{
671  st->size = s ;
672  }
673  *( st->string + st->size ) = '\0';
674 
675  return st->string ;
676 }
677 
678 size_t StringLength( string_t st )
679 {
680  if( st == StringVoid ){
681  return 0 ;
682  }else{
683  return st->size ;
684  }
685 }
686 
687 int StringLengthMatch( string_t st,size_t s )
688 {
689  if( st == StringVoid ){
690  return 0 ;
691  }else{
692  return st->size == s ;
693  }
694 }
695 
696 #if 0
697 const char * StringContent( string_t st )
698 {
699  if( st == StringVoid ){
700  return NULL ;
701  }else{
702  return st->string ;
703  }
704 }
705 
706 const char ** StringPointer( string_t st )
707 {
708  if( st == StringVoid ){
709  return NULL ;
710  }else{
711  return ( const char ** )&st->string ;
712  }
713 }
714 #endif
715 
716 char * StringCopy_1( string_t st )
717 {
718  if( st == StringVoid ){
719  return NULL ;
720  }else{
721  return StringCopy_3( st,st->size ) ;
722  }
723 }
724 
725 char * StringCopy_2( const char * str )
726 {
727  char * c ;
728  size_t len ;
729  if( str == NULL ){
730  c = malloc( sizeof( char ) ) ;
731  if( c == NULL ){
732  return _StringError() ;
733  }else{
734  *c = '\0' ;
735  return c ;
736  }
737  }else{
738  len = strlen( str ) ;
739  c = malloc( sizeof( char ) * ( len + 1 ) ) ;
740  if( c == NULL ){
741  return _StringError() ;
742  }else{
743  memcpy( c,str,len + 1 ) ;
744  return c ;
745  }
746  }
747 }
748 
749 char * StringCopy_3( string_t st,size_t l )
750 {
751  char * c ;
752  if( st == StringVoid ){
753  c = malloc( sizeof( char ) ) ;
754  if( c == NULL ){
755  return _StringError() ;
756  }else{
757  *c = '\0' ;
758  return c ;
759  }
760  }else{
761  c = malloc( sizeof( char ) * ( l + 1 ) ) ;
762  if( c == NULL ){
763  return _StringError() ;
764  }else{
765  memcpy( c,st->string,l ) ;
766  *( c + l ) = '\0' ;
767  return c ;
768  }
769  }
770 }
771 
772 static int _string_ends_with( const char * e,size_t ee,const char * s,size_t ss )
773 {
774  if( ee >= ss ){
775  return memcmp( e + ee - ss,s,ss ) == 0 ;
776  }else{
777  return 0 ;
778  }
779 }
780 
781 int StringEndsWith( string_t st,const char * s )
782 {
783  if( st == StringVoid || s == NULL ){
784  return 0 ;
785  }else{
786  return _string_ends_with( st->string,st->size,s,strlen( s ) ) ;
787  }
788 }
789 
790 int StringEndsWith_1( const char * e,const char * s )
791 {
792  if( e == NULL || s == NULL ){
793  return 0 ;
794  }else{
795  return _string_ends_with( e,strlen( e ),s,strlen( s ) ) ;
796  }
797 }
798 
800 {
801  if( e == StringVoid || s == StringVoid ){
802  return 0 ;
803  }else{
804  return _string_ends_with( e->string,e->size,s->string,s->size ) ;
805  }
806 }
807 
808 int StringStartsAndEndsWith( const char * a,const char * b,const char * c )
809 {
810  if( a == NULL || b == NULL || c == NULL ){
811  return 0 ;
812  }else{
813  if( strncmp( a,b,strlen( b ) ) == 0 ){
814  return _string_ends_with( a,strlen( a ),c,strlen( c ) ) ;
815  }else{
816  return 0 ;
817  }
818  }
819 }
820 
821 int StringStartsWith( string_t st,const char * s )
822 {
823  if( st == StringVoid || s == NULL ){
824  return 0 ;
825  }else{
826  return strncmp( st->string,s,strlen( s ) ) == 0 ;
827  }
828 }
829 
831 {
832  if( st == StringVoid || xt == StringVoid ){
833  return 0 ;
834  }else{
835  return strncmp( st->string,xt->string,xt->size ) == 0 ;
836  }
837 }
838 
839 int StringEndsWithChar( string_t st,char s )
840 {
841  if( st == StringVoid || st->size < 1 ){
842  return 0 ;
843  }else{
844  return st->string[ st->size - 1 ] == s ;
845  }
846 }
847 
848 char StringCharAt( string_t st,size_t p )
849 {
850  if( st == StringVoid ){
851  return '\0' ;
852  }
853  if( p >= st->size ){
854  return '\0' ;
855  }
856  return *( st->string + p ) ;
857 }
858 
860 {
861  if( st == StringVoid ){
862  return '\0' ;
863  }
864  if( st->size == 0 ){
865  return '\0' ;
866  }
867  return * ( st->string + st->size - 1 ) ;
868 }
869 
870 const char * StringStringAt( string_t st,size_t p )
871 {
872  if( st == StringVoid ){
873  return NULL ;
874  }
875  if( p >= st->size ){
876  return NULL ;
877  }
878  return st->string + p ;
879 }
880 
881 const char * StringSubChar( string_t st,size_t x,char s )
882 {
883  if( st == StringVoid ){
884  return NULL ;
885  }
886  if( x >= st->size ){
887  return st->string ;
888  }
889  st->string[ x ] = s ;
890  return st->string ;
891 }
892 
893 static void Stringsrcs__( string_t st,char x,const char * y,size_t p )
894 {
895  size_t i ;
896  size_t j ;
897  size_t k ;
898  size_t l ;
899  char * c ;
900 
901  if( st == StringVoid ){
902  return ;
903  }
904  if( y == NULL ){
905  return ;
906  }
907  if( p >= st->size ){
908  return ;
909  }
910 
911  c= st->string ;
912  l = st->size ;
913  k = strlen( y ) ;
914 
915  for( j = p ; j < l ; j++ ){
916  for( i = 0 ; i < k ; i++ ){
917  if( *( c + j ) == * ( y + i ) ){
918  *( c + j ) = x ;
919  break ;
920  }
921  }
922  }
923 }
924 
925 const char * StringReplaceCharStringPos( string_t st,char x,const char * y,size_t p )
926 {
927  Stringsrcs__( st,x,y,p ) ;
928  return st->string ;
929 }
930 
931 const char * StringReplaceCharString( string_t st,char x,const char * y )
932 {
933  return StringReplaceCharStringPos( st,x,y,0 ) ;
934 }
935 
936 const char * StringSubString( string_t st, size_t x,const char * s )
937 {
938  size_t k ;
939  if( st == StringVoid ){
940  return NULL ;
941  }
942  if( x >= st->size || s == NULL ){
943  return st->string ;
944  }
945  k = strlen( s ) ;
946  if( x + k >= st->size ){
947  return NULL ;
948  }
949  memcpy( st->string + x,s,k );
950  return st->string ;
951 }
952 
953 const char * StringInsertChar( string_t st,size_t x,char s )
954 {
955  char c[ 2 ] = { '\0' } ;
956  *c = s ;
957  return StringInsertString( st,x,c ) ;
958 }
959 
960 const char * StringAppendAt( string_t st,size_t x,const char * s )
961 {
962  size_t len ;
963  char * c ;
964 
965  if( st == StringVoid ){
966  return NULL ;
967  }
968  if( x > st->size || s == NULL ){
969  return st->string ;
970  }
971 
972  len = strlen( s ) ;
973  c = __StringExpandMemory( st,st->size + len ) ;
974 
975  if( c != NULL ){
976  memcpy( c + x,s,len + 1 ) ;
977  st->string = c ;
978  st->size = x + len ;
979  }
980 
981  return c ;
982 }
983 
984 const char * StringReplace( string_t st,const char * s )
985 {
986  size_t len ;
987  char * c ;
988 
989  if( st == StringVoid ){
990  return s ;
991  }
992  if( s == NULL ){
993  return NULL ;
994  }else{
995  len = strlen( s ) ;
996  if( len < st->length ){
997  c = st->string ;
998  memcpy( c,s,len + 1 ) ;
999  st->size = len ;
1000  return c ;
1001  }else{
1002  c = __StringExpandMemory( st,st->size + len ) ;
1003 
1004  if( c != NULL ){
1005  memcpy( c,s,len + 1 ) ;
1006  st->string = c ;
1007  st->size = len ;
1008  }
1009 
1010  return c ;
1011  }
1012  }
1013 }
1014 
1015 const char * StringPrepend( string_t st,const char * s )
1016 {
1017  char * c ;
1018  size_t len ;
1019 
1020  if( st == StringVoid ){
1021  return NULL ;
1022  }
1023  if( s == NULL ){
1024  return st->string ;
1025  }
1026 
1027  len = strlen( s ) ;
1028 
1029  c = __StringExpandMemory( st,st->size + len ) ;
1030 
1031  if( c != NULL ){
1032  st->string = c ;
1033  memmove( st->string + len,st->string,st->size + 1 ) ;
1034  memcpy( st->string,s,len ) ;
1035  st->size += len ;
1036  }
1037  return c ;
1038 }
1039 
1041 {
1042  return StringPrepend( st,xt->string ) ;
1043 }
1044 
1045 const char * StringPrependChar( string_t st,char c )
1046 {
1047  char s[ 2 ] = { '\0' } ;
1048  *s = c ;
1049  return StringPrepend( st,s ) ;
1050 }
1051 
1052 const char * StringAppend( string_t st,const char * s )
1053 {
1054  char * c ;
1055  size_t len ;
1056 
1057  if( st == StringVoid ){
1058  return NULL ;
1059  }
1060  if( s == NULL ){
1061  return st->string ;
1062  }
1063 
1064  len = strlen( s ) ;
1065 
1066  c = __StringExpandMemory( st,st->size + len ) ;
1067 
1068  if( c != NULL ){
1069  st->string = c ;
1070  memcpy( st->string + st->size,s,len + 1 ) ;
1071  st->size += len ;
1072  }
1073  return c ;
1074 }
1075 
1077 {
1078  int r = 0 ;
1079  const char * entry ;
1080  va_list list ;
1081  va_start( list,st ) ;
1082 
1083  if( st != StringVoid ){
1084 
1085  while( 1 ){
1086 
1087  entry = va_arg( list,const char * ) ;
1088 
1089  if( entry == NULL ){
1090  break ;
1091  }else{
1092  if( strncmp( st->string,entry,strlen( entry ) ) == 0 ){
1093  r = 1 ;
1094  break ;
1095  }
1096  }
1097  }
1098  }
1099 
1100  va_end( list ) ;
1101  return r ;
1102 }
1103 
1104 int StringEndsWithAtLeastOne( const char * e,... )
1105 {
1106  const char * entry ;
1107  va_list list ;
1108  va_start( list,e ) ;
1109  int r = 0 ;
1110  while( 1 ){
1111  entry = va_arg( list,const char * ) ;
1112  if( entry == NULL ){
1113  break ;
1114  }else if( StringEndsWith_1( e,entry ) ){
1115  r = 1 ;
1116  break ;
1117  }
1118  }
1119  va_end( list ) ;
1120  return r ;
1121 }
1122 
1123 const char * StringMultipleAppend( string_t st,... )
1124 {
1125  const char * entry ;
1126  va_list list ;
1127  va_start( list,st ) ;
1128 
1129  while( 1 ){
1130  entry = va_arg( list,const char * ) ;
1131  if( entry == NULL ){
1132  break ;
1133  }
1134  StringAppend( st,entry ) ;
1135  }
1136 
1137  va_end( list ) ;
1138  return st->string ;
1139 }
1140 
1141 const char * StringAppendMultipleString( string_t st,... )
1142 {
1143  string_t entry ;
1144  va_list list ;
1145  va_start( list,st ) ;
1146 
1147  while( 1 ){
1148  entry = va_arg( list,string_t ) ;
1149  if( entry == NULL ){
1150  break ;
1151  }
1152  StringAppend( st,entry->string ) ;
1153  }
1154 
1155  va_end( list ) ;
1156  return st->string ;
1157 }
1158 
1159 const char * StringMultiplePrepend( string_t st,... )
1160 {
1161  const char * entry ;
1162  va_list list ;
1163  va_start( list,st ) ;
1164 
1165  while( 1 ){
1166  entry = va_arg( list,const char * ) ;
1167  if( entry == NULL ){
1168  break ;
1169  }
1170  StringPrepend( st,entry ) ;
1171  }
1172 
1173  va_end( list ) ;
1174  return st->string ;
1175 }
1176 
1178 {
1179  string_t entry ;
1180  va_list list ;
1181  va_start( list,st ) ;
1182 
1183  while( 1 ){
1184  entry = va_arg( list,string_t ) ;
1185  if( entry == NULL ){
1186  break ;
1187  }
1188  StringPrepend( st,entry->string ) ;
1189  }
1190 
1191  va_end( list ) ;
1192  return st->string ;
1193 }
1194 
1195 const char * StringAppendString( string_t st,string_t xt )
1196 {
1197  if( xt != StringVoid ){
1198 
1199  return StringAppend( st,xt->string ) ;
1200  }else{
1201  return StringContent( st ) ;
1202  }
1203 }
1204 
1205 const char * StringAppendChar( string_t st,char c )
1206 {
1207  char * d = __StringExpandMemory( st,st->size + 1 ) ;
1208 
1209  if( d != NULL ){
1210  st->string[ st->size ] = c ;
1211  st->string[ st->size + 1 ] = '\0' ;
1212  st->size += 1 ;
1213  }
1214 
1215  return d ;
1216 }
1217 
1218 const char * StringInsertString( string_t st,size_t x,const char * s )
1219 {
1220  char * c ;
1221  size_t len ;
1222 
1223  if( s == NULL ){
1224  return NULL ;
1225  }
1226 
1227  len = strlen( s ) ;
1228 
1229  c = __StringExpandMemory( st,len ) ;
1230 
1231  if( c != NULL ){
1232  st->string = c ;
1233  memmove( st->string + len + x,st->string + x,st->size - x + 1 ) ;
1234  memcpy( st->string + x,s,len ) ;
1235  st->size += len ;
1236  }
1237  return c ;
1238 }
1239 
1240 string_t StringMidString( string_t st,size_t x,size_t y )
1241 {
1242  char * c ;
1243 
1244  c = malloc( sizeof( char ) * ( y + 1 ) ) ;
1245  if( c == NULL ){
1246  return _StringError() ;
1247  }
1248  strncpy( c,st->string + x, y ) ;
1249 
1250  *( c + y ) = '\0' ;
1251 
1252  return StringInheritWithSize( &c,y,y + 1 ) ;
1253 }
1254 
1255 static char * StringRS__( string_t st,const char * x,const char * s,size_t p )
1256 {
1257  char * c ;
1258  char * d ;
1259  char * e ;
1260 
1261  size_t j ;
1262  size_t k ;
1263  size_t len ;
1264 
1265  if( st == StringVoid ){
1266  return NULL ;
1267  }
1268 
1269  if( x == NULL || s == NULL || p >= st->size ){
1270  return st->string ;
1271  }
1272 
1273  d = st->string ;
1274  e = st->string + p ;
1275 
1276  j = strlen( s ) ;
1277  k = strlen( x ) ;
1278 
1279  if( j == k ){
1280  while( ( c = strstr( e,x ) ) != NULL ){
1281  memcpy( c,s,j ) ;
1282  e = e + j ;
1283  }
1284  }else if( j > k ){
1285  while( ( c = strstr( e,x ) ) != NULL ){
1286  len = c - st->string ;
1287  d = __StringExpandMemory( st,st->size + j ) ;
1288  if( d != NULL ){
1289  st->string = d ;
1290  c = st->string + len ;
1291  memmove( c + j,c + k,st->size - ( c - st->string ) + 1 ) ;
1292  memcpy( c,s,j ) ;
1293  st->size = st->size + j - k ;
1294  e = st->string + len + j ;
1295  }
1296  }
1297  }else if( k > j ){
1298  while( ( c = strstr( e,x ) ) != NULL ){
1299  len = c - st->string ;
1300  memmove( c + j,c + k,st->size - ( c - st->string + k ) + 1 ) ;
1301  memcpy( c,s,j ) ;
1302  if( d != NULL ){
1303  st->string = d ;
1304  st->size = st->size +j - k ;
1305  e = st->string + len ;
1306  }
1307  }
1308  }
1309 
1310  return d ;
1311 }
1312 
1313 const char * StringReplaceStringPos( string_t st,const char * x,const char * s,size_t p )
1314 {
1315  return StringRS__( st,x,s,p ) ;
1316 }
1317 
1318 const char * StringReplaceString( string_t st,const char * x,const char * s )
1319 {
1320  return StringReplaceStringPos( st,x,s,0 ) ;
1321 }
1322 
1323 const char * StringRemoveStringPos( string_t st,const char * s,size_t p )
1324 {
1325  return StringRS__( st,s,"",p ) ;
1326 }
1327 
1328 const char * StringRemoveString( string_t st,const char * s )
1329 {
1330  return StringRemoveStringPos( st,s,0 ) ;
1331 }
1332 
1334 {
1335  if( x == StringVoid ){
1336  return 0 ;
1337  }else{
1338  return x->string[ 0 ] == '\0' ;
1339  }
1340 }
1341 
1342 static char * StringCRC__( string_t st, char x,char y,size_t p )
1343 {
1344  char * c ;
1345  if( st == StringVoid ){
1346  return NULL ;
1347  }
1348  if( p >= st->size ){
1349  return st->string ;
1350  }
1351  c = st->string - 1 + p ;
1352  while( *++c ){
1353  if( *c == x ){
1354  *c = y ;
1355  }
1356  }
1357  return st->string ;
1358 }
1359 
1360 const char * StringReplaceCharPos( string_t st,char x,char y,size_t p )
1361 {
1362  return StringCRC__( st,x,y,p ) ;
1363 }
1364 
1365 const char * StringReplaceChar_1( string_t st,size_t index,char x,char y )
1366 {
1367  char * e ;
1368  if( st == StringVoid ){
1369  return NULL ;
1370  }
1371  if( index >= st->size ){
1372  return NULL ;
1373  }
1374  e = strchr( st->string + index,x ) ;
1375  if( e != NULL ){
1376  *e = y ;
1377  return st->string ;
1378  }else{
1379  return NULL ;
1380  }
1381 }
1382 
1383 const char * StringReplaceChar( string_t st,char x,char y )
1384 {
1385  return StringReplaceCharPos( st,x,y,0 ) ;
1386 }
1387 
1388 /*
1389  * 2^64 has a maximum of 19 digits,64 byte buffer is more that enough
1390  */
1391 #define BUFFSIZE 64
1392 #define BUFFLIMIT 63
1393 static inline char * _intToString( char * buffer,u_int64_t z )
1394 {
1395  int i = BUFFLIMIT ;
1396  do{
1397  i-- ;
1398  buffer[ i ] = z % 10 + '0' ;
1399  z = z / 10 ;
1400  }while( z != 0 && i != 0 ) ;
1401  return buffer + i ;
1402 }
1403 
1405 {
1406  char buffer[ BUFFSIZE ] = { '\0' };
1407  return String( _intToString( buffer,z ) );
1408 }
1409 
1410 const char * StringAppendInt( string_t st,u_int64_t z )
1411 {
1412  char buffer[ BUFFSIZE ] = { '\0' };
1413  return StringAppend( st,_intToString( buffer,z ) ) ;
1414 }
1415 
1416 u_int64_t StringConvertToInt( const char * s )
1417 {
1418  u_int64_t r = 0 ;
1419 
1420  char c ;
1421 
1422  if( s == NULL ){
1423  return 0 ;
1424  }
1425 
1426  while( 1 ){
1427  c = *s ;
1428  s++ ;
1429  if( c == '\0' ){
1430  break ;
1431  }else{
1432  r = r * 10 + ( c - '0' ) ;
1433  }
1434  }
1435  return r ;
1436 }
1437 
1438 const char * StringSubStringWithInt( string_t st,const char * str,u_int64_t z )
1439 {
1440  char buffer[ BUFFSIZE ] = { '\0' };
1441  return StringReplaceString( st,str,_intToString( buffer,z ) ) ;
1442 }
1443 
1444 char * StringIntToString_1( char * x,size_t y,u_int64_t z )
1445 {
1446  char * c ;
1447  if( x == NULL ){
1448  return NULL ;
1449  }else{
1450  c = x + y - 1 ;
1451  *c-- = '\0' ;
1452  do{
1453  *c-- = z % 10 + '0' ;
1454  z = z / 10 ;
1455  }while( z != 0 ) ;
1456  return ++c ;
1457  }
1458 }
1459 
1461 {
1462  if( x == StringVoid || y == StringVoid || x->size != y->size ){
1463  return 0 ;
1464  }else{
1465  return strcmp( x->string,y->string ) == 0 ;
1466  }
1467 }
1468 
1469 int StringsAreEqual_2( string_t x,const char * y )
1470 {
1471  if( x == StringVoid ){
1472  return 0 ;
1473  }else{
1474  return strcmp( x->string,y ) == 0 ;
1475  }
1476 }
1477 
1479 {
1480  va_list list ;
1481  int r = 0 ;
1482  const char * e ;
1483  const char * f ;
1484 
1485  va_start( list,st ) ;
1486 
1487  if( st != StringVoid ){
1488  f = st->string ;
1489  while( 1 ){
1490  e = va_arg( list,const char * ) ;
1491  if( e == NULL ){
1492  break ;
1493  }else if( strcmp( f,e ) == 0 ){
1494  r = 1 ;
1495  break ;
1496  }
1497  }
1498  }
1499 
1500  va_end( list ) ;
1501  return r ;
1502 }
1503 
1504 int StringAtLeastOneMatch_1( const char * x,... )
1505 {
1506  va_list list ;
1507  int r = 0 ;
1508  const char * e ;
1509 
1510  va_start( list,x ) ;
1511 
1512  if( x != NULL ){
1513  while( 1 ){
1514  e = va_arg( list,const char * ) ;
1515  if( e == NULL ){
1516  break ;
1517  }else if( strcmp( x,e ) == 0 ){
1518  r = 1 ;
1519  break ;
1520  }
1521  }
1522  }
1523 
1524  va_end( list ) ;
1525  return r ;
1526 }
1527 
1528 int StringHasAtLeastOneComponent_1( const char * x,... )
1529 {
1530  va_list list ;
1531  int r = 0 ;
1532  const char * e ;
1533 
1534  va_start( list,x ) ;
1535 
1536  if( x != NULL ){
1537  while( 1 ){
1538  e = va_arg( list,const char * ) ;
1539  if( e == NULL ){
1540  break ;
1541  }else if( strstr( x,e ) != NULL ){
1542  r = 1 ;
1543  break ;
1544  }
1545  }
1546  }
1547 
1548  va_end( list ) ;
1549  return r ;
1550 }
1551 
1553 {
1554  va_list list ;
1555  int r = 0 ;
1556  const char * e ;
1557  const char * f ;
1558 
1559  va_start( list,st ) ;
1560 
1561  if( st != StringVoid ){
1562  f = st->string ;
1563  while( 1 ){
1564  e = va_arg( list,const char * ) ;
1565  if( e == NULL ){
1566  break ;
1567  }else if( strstr( f,e ) != NULL ){
1568  r = 1 ;
1569  break ;
1570  }
1571  }
1572  }
1573 
1574  va_end( list ) ;
1575  return r ;
1576 }
1577 
1578 int StringAtLeastOnePrefixMatch( const char * x,... )
1579 {
1580  va_list list ;
1581  int r = 0 ;
1582  const char * e ;
1583 
1584  va_start( list,x ) ;
1585 
1586  if( x != NULL ){
1587  while( 1 ){
1588  e = va_arg( list,const char * ) ;
1589  if( e == NULL ){
1590  break ;
1591  }else if( strncmp( x,e,strlen( e ) ) == 0 ){
1592  r = 1 ;
1593  break ;
1594  }
1595  }
1596  }
1597 
1598  va_end( list ) ;
1599  return r ;
1600 }
1601 
1602 static char * StringICS__( string_t st,char x,const char * s,size_t p )
1603 {
1604  const char * d ;
1605  char * e ;
1606  char * f ;
1607  size_t pos ;
1608 
1609  if( st == StringVoid ){
1610  return NULL ;
1611  }
1612  if( p >= st->size || s == NULL ){
1613  return st->string ;
1614  }
1615  d = s - 1 ;
1616  while( *++d ){
1617  f = st->string - 1 + p ;
1618  while( *++f ){
1619  if( *d == *f ){
1620  pos = f - st->string ;
1621  e = __StringExpandMemory( st,st->size + 2 ) ;
1622  if( e != NULL ){
1623  st->string = e ;
1624  memmove( e + pos + 1,e + pos,st->size - pos + 1 ) ;
1625  *( e + pos ) = x ;
1626  f = e + pos + 1 ;
1627  st->size++ ;
1628  }
1629  }
1630  }
1631  }
1632  return st->string ;
1633 }
1634 
1635 const char * StringInsertCharStringPos( string_t st,char x,const char * s,size_t p )
1636 {
1637  return StringICS__( st,x,s,p ) ;
1638 }
1639 
1640 const char * StringInsertCharString( string_t st,char x,const char * s )
1641 {
1642  return StringInsertCharStringPos( st,x,s,0 ) ;
1643 }
1644 
1645 const char * StringInsertCharChar( string_t st,char x,char y )
1646 {
1647  char c[2] ;
1648  c[0] = y ;
1649  c[1] = '\0' ;
1650  return StringInsertCharString( st,x,c ) ;
1651 }
1652 
1654 {
1655  int c ;
1656  const char * d ;
1657  string_t p = String( "" ) ;
1658 
1659  while( 1 ){
1660  c = getchar() ;
1661  if( c == '\n' || c == EOF ){
1662  break ;
1663  }else{
1664  d = StringAppendChar( p,( char )c ) ;
1665  if( d == NULL ){
1666  StringDelete( &p ) ;
1667  return StringVoid ;
1668  }
1669  }
1670  }
1671 
1672  return p ;
1673 }
1674 
1676 {
1677  int c ;
1678  const char * d ;
1679  string_t p = String( "" ) ;
1680 
1681  while( 1 ){
1682  if( s == 0 ){
1683  /*
1684  * we already got the requested number of characters,now clear the buffer
1685  * by reading until we get a newline or EOF character
1686  */
1687  while( 1 ){
1688  c = getchar() ;
1689  if( c == '\n' || c == EOF ){
1690  break ;
1691  }
1692  }
1693 
1694  return p ;
1695  }
1696 
1697  c = getchar() ;
1698 
1699  if( c == '\n' || c == EOF ){
1700  break ;
1701  }else{
1702  s-- ;
1703  d = StringAppendChar( p,( char )c ) ;
1704  if( d == NULL ){
1705  StringDelete( &p ) ;
1706  return StringVoid ;
1707  }
1708  }
1709  }
1710 
1711  return p ;
1712 }
1713 
1714 static inline int __terminalEchoOff( struct termios * old,struct termios * new )
1715 {
1716  if( tcgetattr ( 1,old ) != 0 ){
1717  return 1 ;
1718  }
1719 
1720  *new = *old;
1721  new->c_lflag &= ~ECHO;
1722 
1723  if( tcsetattr ( 1,TCSAFLUSH,new ) != 0 ){
1724  return 1 ;
1725  }else{
1726  return 0 ;
1727  }
1728 }
1729 
1731 {
1732  string_t p ;
1733  struct termios old ;
1734  struct termios new ;
1735 
1736  if( __terminalEchoOff( &old,&new ) == 1 ){
1737  return 1 ;
1738  }
1739 
1740  p = StringGetFromTerminal() ;
1741 
1742  if( p == StringVoid ){
1743  return 2 ;
1744  }
1745 
1746  tcsetattr( 1,TCSAFLUSH,&old );
1747 
1748  *q = p ;
1749  return 0 ;
1750 }
1751 
1753 {
1754  string_t p ;
1755  struct termios old ;
1756  struct termios new ;
1757 
1758  if( __terminalEchoOff( &old,&new ) == 1 ){
1759  return 1 ;
1760  }
1761  p = StringGetFromTerminal_1( s ) ;
1762  if( p == StringVoid ){
1763  return 2 ;
1764  }
1765  tcsetattr ( 1,TCSAFLUSH,&old );
1766 
1767  *q = p ;
1768  return 0 ;
1769 }
1770 
1772 {
1773  string_t s = StringVoid ;
1774  char * e ;
1775  char c ;
1776  int f ;
1777  size_t g = 0 ;
1778 
1779  if( size < 1 ){
1780  return s ;
1781  }
1782 
1783  e = malloc( sizeof( char ) * ( size + 1 ) ) ;
1784 
1785  if( e == NULL ){
1786  return s ;
1787  }
1788 
1789  f = open( "/dev/urandom",O_RDONLY ) ;
1790 
1791  if( f == -1 ){
1792  free( e ) ;
1793  return s ;
1794  }
1795 
1796  while( g < size ){
1797  ignore_result( read( f,&c,1 ) ) ;
1798  if( c >= ' ' && c <= '~' ){
1799  *( e + g ) = c ;
1800  g++ ;
1801  }
1802  }
1803 
1804  *( e + size ) = '\0' ;
1805 
1806  close( f ) ;
1807 
1808  s = StringInheritWithSize( &e,size,size + 1 ) ;
1809 
1810  if( s == StringVoid ){
1811  free( e ) ;
1812  }
1813  return s ;
1814 }
1815 
1816 u_int32_t StringJenkinsOneAtATimeHash( const char * key )
1817 {
1818  size_t l ;
1819  u_int32_t hash = 0;
1820  u_int32_t i ;
1821 
1822  if( key != NULL ){
1823  l = strlen( key ) ;
1824  for( i = 0 ; i < l ; i++ ){
1825  hash += key[ i ];
1826  hash += ( hash << 10 );
1827  hash ^= ( hash >> 6 );
1828  }
1829  hash += ( hash << 3 );
1830  hash ^= ( hash >> 11 );
1831  hash += ( hash << 15 );
1832  }
1833  return hash;
1834 }
1835 
1837 {
1838  size_t l ;
1839  u_int32_t hash = 0;
1840  u_int32_t i ;
1841  const char * e ;
1842 
1843  if( st != StringVoid ){
1844  e = st->string ;
1845  l = st->size ;
1846  for( i = 0 ; i < l ; i++ ){
1847  hash += e[ i ];
1848  hash += ( hash << 10 );
1849  hash ^= ( hash >> 6 );
1850  }
1851  hash += ( hash << 3 );
1852  hash ^= ( hash >> 11 );
1853  hash += ( hash << 15 );
1854  }
1855  return hash ;
1856 }
1857 
1858 int StringGetFromFile_1( string_t * str,const char * path )
1859 {
1860  struct stat st ;
1861  if( stat( path,&st ) != 0 ){
1862  return 1 ;
1863  }else{
1864  return StringGetFromFile_3( str,path,0,st.st_size ) ;
1865  }
1866 }
1867 
1868 int StringGetFromFile_3( string_t * str,const char * path,size_t offset,size_t length )
1869 {
1870  int fd ;
1871  char * c ;
1872  ssize_t size ;
1873 
1874  struct stat xt ;
1875 
1876  *str = StringVoid ;
1877  if( path == NULL ){
1878  return 1 ;
1879  }
1880  if( stat( path,&xt ) != 0 ){
1881  return 1 ;
1882  }
1883  if( ( fd = open( path,O_RDONLY ) ) == -1 ){
1884  return 2 ;
1885  }
1886  if( lseek( fd,offset,SEEK_SET ) == -1 ){
1887  close( fd ) ;
1888  return 2 ;
1889  }
1890 
1891  c = malloc( sizeof( char ) * ( length + 1 ) ) ;
1892 
1893  if( c == NULL ) {
1894  close( fd ) ;
1895  _StringError() ;
1896  return 3 ;
1897  }
1898 
1899  size = read( fd,c,length ) ;
1900 
1901  if( size <= 0 ){
1902  free( c ) ;
1903  close( fd ) ;
1904  return 2 ;
1905  }
1906 
1907  close( fd ) ;
1908 
1909  *( c + length ) = '\0' ;
1910 
1911  *str = StringInheritWithSize( &c,( size_t )size,length + 1 ) ;
1912 
1913  if( *str == StringVoid ){
1914  free( c ) ;
1915  return 3 ;
1916  }else{
1917  return 0 ;
1918  }
1919 }
1920 
1921 int StringGetFromFileMemoryLocked( string_t * str,const char * path,size_t offset,ssize_t length )
1922 {
1923  int fd ;
1924  char * c ;
1925 
1926  ssize_t size ;
1927  ssize_t file_size ;
1928 
1929  size_t reserve_memory_size ;
1930 
1931  struct stat xt ;
1932 
1933  if( path == NULL ){
1934  return 1 ;
1935  }
1936  if( stat( path,&xt ) != 0 ){
1937  return 1 ;
1938  }
1939  if( ( fd = open( path,O_RDONLY ) ) == -1 ){
1940  return 1 ;
1941  }
1942  if( lseek( fd,offset,SEEK_SET ) == -1 ){
1943  close( fd ) ;
1944  return 1 ;
1945  }
1946 
1947  file_size = xt.st_size - offset ;
1948 
1949  if( file_size <= 0 ){
1950  close( fd ) ;
1951  return 1 ;
1952  }
1953  if( length <= 0 ){
1954  reserve_memory_size = xt.st_size ;
1955  }else if( file_size > length ){
1956  reserve_memory_size = length ;
1957  }else{
1958  reserve_memory_size = file_size ;
1959  }
1960 
1961  c = malloc( sizeof( char ) * ( reserve_memory_size + 1 ) ) ;
1962 
1963  if( c == NULL ) {
1964  close( fd ) ;
1965  _StringError() ;
1966  return 2 ;
1967  }
1968 
1969  mlock( c,reserve_memory_size + 1 ) ;
1970 
1971  size = read( fd,c,reserve_memory_size ) ;
1972 
1973  close( fd ) ;
1974 
1975  if( size <= 0 ){
1976  munlock( c,reserve_memory_size + 1 ) ;
1977  free( c ) ;
1978  return 1 ;
1979  }
1980 
1981  *( c + reserve_memory_size ) = '\0' ;
1982 
1983  *str = StringInheritWithSize( &c,( size_t )size,reserve_memory_size + 1 ) ;
1984 
1985  if( *str == StringVoid ){
1986  free( c ) ;
1987  return 2 ;
1988  }else{
1989  return 0 ;
1990  }
1991 }
1992 
1993 string_t StringGetFromFile_2( const char * path,int * status )
1994 {
1995  string_t st = NULL ;
1996  struct stat xt ;
1997  if( stat( path,&xt ) != 0 ){
1998  *status = 1 ;
1999  return StringVoid ;
2000  }else{
2001  *status = StringGetFromFile_3( &st,path,0,xt.st_size ) ;
2002  return st ;
2003  }
2004 }
2005 
2006 string_t StringGetFromFile( const char * path )
2007 {
2008  string_t st = StringVoid ;
2009  StringGetFromFile_1( &st,path ) ;
2010  return st ;
2011 }
2012 
2013 void StringWriteToFile( string_t st,const char * path,int mode )
2014 {
2015  int fd ;
2016 
2017  if( st == StringVoid ){
2018  return ;
2019  }
2020 
2021  if( mode == 1 ){
2022  fd = open( path,O_WRONLY | O_CREAT | O_TRUNC,S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH ) ;
2023  }else{
2024  fd = open( path,O_WRONLY | O_CREAT | O_APPEND,S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH ) ;
2025  }
2026 
2027  if( fd == -1 ){
2028  return ;
2029  }
2030 
2031  ignore_result( write( fd,st->string,st->size ) ) ;
2032 
2033  close( fd ) ;
2034 
2035  ignore_result( chown( path,getuid(),getgid() ) ) ;
2036  chmod( path,S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH ) ;
2037 }
2038 
2039 static inline string_t _freeBuffer( char * buffer,int fd )
2040 {
2041  close( fd ) ;
2042  if( buffer != NULL ){
2043  free( buffer );
2044  return _StringError() ;
2045  }else{
2046  return _StringError() ;
2047  }
2048 }
2049 
2051 {
2052  #define SIZE 64
2053 
2054  char * buffer = NULL ;
2055  char * e ;
2056 
2057  size_t size = SIZE ;
2058  size_t size_1 = 0 ;
2059  size_t strLen ;
2060  size_t bufferLen ;
2061  ssize_t j ;
2062 
2063  int fd = open( path,O_RDONLY ) ;
2064  if( fd == -1 ){
2065  buffer = malloc( sizeof( char ) ) ;
2066  if( buffer == NULL ){
2067  return _StringError() ;
2068  }else{
2069  buffer[0] = '\0' ;
2070  return StringInheritWithSize( &buffer,0,1 ) ;
2071  }
2072  }
2073 
2074  while( 1 ){
2075  e = realloc( buffer,size ) ;
2076  if( e == NULL ){
2077  return _freeBuffer( buffer,fd ) ;
2078  }else{
2079  buffer = e ;
2080  j = read( fd,buffer + size_1,SIZE ) ;
2081  if( j < SIZE ){
2082  if( j <= 0 ){
2083  e = realloc( buffer,size_1 + 1 ) ;
2084  if( e != NULL ){
2085  buffer = e ;
2086  buffer[ size_1 ] = '\0' ;
2087  strLen = size_1 ;
2088  bufferLen = size_1 + 1 ;
2089  }else{
2090  return _freeBuffer( buffer,fd ) ;
2091  }
2092  }else{
2093  buffer[ size_1 + j ] = '\0' ;
2094  strLen = size_1 + j ;
2095  bufferLen = size ;
2096  }
2097  break ;
2098  }else{
2099  size += SIZE ;
2100  size_1 += j ;
2101  }
2102  }
2103  }
2104 
2105  close( fd ) ;
2106 
2107  return StringInheritWithSize( &buffer,strLen,bufferLen ) ;
2108 }
StringRemoveLeft
const char * StringRemoveLeft(string_t st, size_t x)
Definition: String.c:647
StringAppendString
const char * StringAppendString(string_t st, string_t xt)
Definition: String.c:1195
StringSilentlyGetFromTerminal_1
int StringSilentlyGetFromTerminal_1(string_t *q, size_t s)
Definition: String.c:1752
StringReplace
const char * StringReplace(string_t st, const char *s)
Definition: String.c:984
StringAppendInt
const char * StringAppendInt(string_t st, u_int64_t z)
Definition: String.c:1410
StringGetFromVirtualFile
string_t StringGetFromVirtualFile(const char *path)
Definition: String.c:2050
StringAtLeastOneMatch
int StringAtLeastOneMatch(string_t st,...)
Definition: String.c:1478
StringsAreEqual_2
int StringsAreEqual_2(string_t x, const char *y)
Definition: String.c:1469
StringStartsAndEndsWith
int StringStartsAndEndsWith(const char *a, const char *b, const char *c)
Definition: String.c:808
StringWriteToFile
void StringWriteToFile(string_t st, const char *path, int mode)
Definition: String.c:2013
StringReset
void StringReset(string_t st)
Definition: String.c:626
StringGetFromFile_2
string_t StringGetFromFile_2(const char *path, int *status)
Definition: String.c:1993
StringGetFromFile
string_t StringGetFromFile(const char *path)
Definition: String.c:2006
StringSubChar
const char * StringSubChar(string_t st, size_t x, char s)
Definition: String.c:881
StringType::size
size_t size
Definition: String.c:58
SIZE
#define SIZE
StringCopy
string_t StringCopy(string_t st)
Definition: String.c:260
StringReadToBuffer
void StringReadToBuffer(string_t st, char *buffer, size_t size)
Definition: String.c:384
StringPrependChar
const char * StringPrependChar(string_t st, char c)
Definition: String.c:1045
StringCopy_1
char * StringCopy_1(string_t st)
Definition: String.c:716
StringType::length
size_t length
Definition: String.c:62
StringJenkinsOneAtATimeHash_1
u_int32_t StringJenkinsOneAtATimeHash_1(string_t st)
Definition: String.c:1836
StringLength
size_t StringLength(string_t st)
Definition: String.c:678
_f
static void _f(void)
Definition: String.c:69
STRING_INIT_SIZE
#define STRING_INIT_SIZE
Definition: String.c:47
StringICS__
static char * StringICS__(string_t st, char x, const char *s, size_t p)
Definition: String.c:1602
StringRandomString
string_t StringRandomString(size_t size)
Definition: String.c:1771
StringSilentlyGetFromTerminal
int StringSilentlyGetFromTerminal(string_t *q)
Definition: String.c:1730
StringInheritWithSize
string_t StringInheritWithSize(char **data, size_t size, size_t length)
Definition: String.c:429
StringStartsWith
int StringStartsWith(string_t st, const char *s)
Definition: String.c:821
StringLastIndexOfString
ssize_t StringLastIndexOfString(string_t st, const char *s)
Definition: String.c:509
StringIndexOfString
ssize_t StringIndexOfString(string_t st, size_t p, const char *s)
Definition: String.c:468
_freeBuffer
static string_t _freeBuffer(char *buffer, int fd)
Definition: String.c:2039
StringReplaceChar_1
const char * StringReplaceChar_1(string_t st, size_t index, char x, char y)
Definition: String.c:1365
StringStringAt
const char * StringStringAt(string_t st, size_t p)
Definition: String.c:870
StringPrint
void StringPrint(string_t st)
Definition: String.c:406
StringToLowerCase
const char * StringToLowerCase(string_t st)
Definition: String.c:95
__terminalEchoOff
static int __terminalEchoOff(struct termios *old, struct termios *new)
Definition: String.c:1714
StringEndsWith
int StringEndsWith(string_t st, const char *s)
Definition: String.c:781
StringIntToString_1
char * StringIntToString_1(char *x, size_t y, u_int64_t z)
Definition: String.c:1444
StringAppendMultipleString
const char * StringAppendMultipleString(string_t st,...)
Definition: String.c:1141
StringEndsWithAtLeastOne
int StringEndsWithAtLeastOne(const char *e,...)
Definition: String.c:1104
StringReplaceStringPos
const char * StringReplaceStringPos(string_t st, const char *x, const char *s, size_t p)
Definition: String.c:1313
_memory_error
static void(* _memory_error)(void)
Definition: String.c:73
StringPrepend
const char * StringPrepend(string_t st, const char *s)
Definition: String.c:1015
StringHasAtLeastOneComponent
int StringHasAtLeastOneComponent(string_t st,...)
Definition: String.c:1552
StringMultipleAppend
const char * StringMultipleAppend(string_t st,...)
Definition: String.c:1123
StringStartsWith_1
int StringStartsWith_1(string_t st, string_t xt)
Definition: String.c:830
StringCopy_2
char * StringCopy_2(const char *str)
Definition: String.c:725
StringLengthMatch
int StringLengthMatch(string_t st, size_t s)
Definition: String.c:687
StringReplaceChar
const char * StringReplaceChar(string_t st, char x, char y)
Definition: String.c:1383
StringCopy_3
char * StringCopy_3(string_t st, size_t l)
Definition: String.c:749
_string_ends_with
static int _string_ends_with(const char *e, size_t ee, const char *s, size_t ss)
Definition: String.c:772
StringRemoveString
const char * StringRemoveString(string_t st, const char *s)
Definition: String.c:1328
BUFFLIMIT
#define BUFFLIMIT
Definition: String.c:1392
StringGetFromFile_1
int StringGetFromFile_1(string_t *str, const char *path)
Definition: String.c:1858
StringContains
int StringContains(string_t st, const char *str)
Definition: String.c:420
StringRemoveLength
const char * StringRemoveLength(string_t st, size_t x, size_t y)
Definition: String.c:568
StringLastIndexOfChar
ssize_t StringLastIndexOfChar(string_t st, char s)
Definition: String.c:488
StringInsertCharStringPos
const char * StringInsertCharStringPos(string_t st, char x, const char *s, size_t p)
Definition: String.c:1635
StringCRC__
static char * StringCRC__(string_t st, char x, char y, size_t p)
Definition: String.c:1342
StringDeleteHandle
char * StringDeleteHandle(string_t *xt)
Definition: String.c:233
StringReplaceCharPos
const char * StringReplaceCharPos(string_t st, char x, char y, size_t p)
Definition: String.c:1360
StringReplaceCharString
const char * StringReplaceCharString(string_t st, char x, const char *y)
Definition: String.c:931
_StringError
static void * _StringError(void)
Definition: String.c:80
StringJenkinsOneAtATimeHash
u_int32_t StringJenkinsOneAtATimeHash(const char *key)
Definition: String.c:1816
StringInherit
string_t StringInherit(char **data)
Definition: String.c:391
StringAtLeastOneMatch_1
int StringAtLeastOneMatch_1(const char *x,...)
Definition: String.c:1504
StringContent
static const __inline__ char * StringContent(string_t st)
Definition: String.h:1011
StringType
Definition: String.c:49
StringAppendAt
const char * StringAppendAt(string_t st, size_t x, const char *s)
Definition: String.c:960
_intToString
static char * _intToString(char *buffer, u_int64_t z)
Definition: String.c:1393
StringsAreEqual_1
int StringsAreEqual_1(string_t x, string_t y)
Definition: String.c:1460
StringMultipleDelete
void StringMultipleDelete(string_t *xt,...)
Definition: String.c:195
StringIntToString
string_t StringIntToString(u_int64_t z)
Definition: String.c:1404
Stringsrcs__
static void Stringsrcs__(string_t st, char x, const char *y, size_t p)
Definition: String.c:893
StringBuffer
string_t StringBuffer(size_t s)
Definition: String.c:297
String
string_t String(const char *cstring)
Definition: String.c:318
StringEmpty
string_t StringEmpty()
Definition: String.c:292
StringIndexOfChar
ssize_t StringIndexOfChar(string_t st, size_t p, char s)
Definition: String.c:548
siritask::status
status
Definition: siritask.h:114
String_1
string_t String_1(const char *cstring,...)
Definition: String.c:363
StringStartsWithAtLeastOne
int StringStartsWithAtLeastOne(string_t st,...)
Definition: String.c:1076
StringInsertCharString
const char * StringInsertCharString(string_t st, char x, const char *s)
Definition: String.c:1640
StringType::string
char * string
Definition: String.c:54
StringReplaceCharStringPos
const char * StringReplaceCharStringPos(string_t st, char x, const char *y, size_t p)
Definition: String.c:925
StringLock
int StringLock(string_t st)
Definition: String.c:144
StringCharAtLast
char StringCharAtLast(string_t st)
Definition: String.c:859
StringPrependString
const char * StringPrependString(string_t st, string_t xt)
Definition: String.c:1040
StringGetFromTerminal
string_t StringGetFromTerminal(void)
Definition: String.c:1653
StringAppendChar
const char * StringAppendChar(string_t st, char c)
Definition: String.c:1205
StringEndsWith_1
int StringEndsWith_1(const char *e, const char *s)
Definition: String.c:790
StringReplaceString
const char * StringReplaceString(string_t st, const char *x, const char *s)
Definition: String.c:1318
StringEndsWithChar
int StringEndsWithChar(string_t st, char s)
Definition: String.c:839
__StringExpandMemory
static char * __StringExpandMemory(string_t st, size_t new_size)
Definition: String.c:117
ignore_result
#define ignore_result(x)
Definition: String.c:37
StringUnlock
int StringUnlock(string_t st)
Definition: String.c:153
StringInsertString
const char * StringInsertString(string_t st, size_t x, const char *s)
Definition: String.c:1218
StringMidString
string_t StringMidString(string_t st, size_t x, size_t y)
Definition: String.c:1240
StringEndsWith_2
int StringEndsWith_2(string_t e, string_t s)
Definition: String.c:799
e
static QString e
Definition: about.cpp:31
StringMultiplePrepend
const char * StringMultiplePrepend(string_t st,...)
Definition: String.c:1159
StringIterator
char * StringIterator
Definition: String.h:49
StringAtLeastOnePrefixMatch
int StringAtLeastOnePrefixMatch(const char *x,...)
Definition: String.c:1578
StringGetFromFile_3
int StringGetFromFile_3(string_t *str, const char *path, size_t offset, size_t length)
Definition: String.c:1868
StringHasAtLeastOneComponent_1
int StringHasAtLeastOneComponent_1(const char *x,...)
Definition: String.c:1528
StringDelete
void StringDelete(string_t *st)
Definition: String.c:162
StringIsEmpty
int StringIsEmpty(string_t x)
Definition: String.c:1333
StringCharAt
char StringCharAt(string_t st, size_t p)
Definition: String.c:848
StringConvertToInt
u_int64_t StringConvertToInt(const char *s)
Definition: String.c:1416
String.h
StringRS__
static char * StringRS__(string_t st, const char *x, const char *s, size_t p)
Definition: String.c:1255
StringGetFromTerminal_1
string_t StringGetFromTerminal_1(size_t s)
Definition: String.c:1675
StringGetIterators
void StringGetIterators(string_t st, StringIterator *begin, StringIterator *end)
Definition: String.c:133
StringWithSize
string_t StringWithSize(const char *s, size_t len)
Definition: String.c:453
StringGetFromFileMemoryLocked
int StringGetFromFileMemoryLocked(string_t *str, const char *path, size_t offset, ssize_t length)
Definition: String.c:1921
StringExitOnMemoryExaustion
void StringExitOnMemoryExaustion(void(*f)(void))
Definition: String.c:75
StringInsertChar
const char * StringInsertChar(string_t st, size_t x, char s)
Definition: String.c:953
StringPrintLine
void StringPrintLine(string_t st)
Definition: String.c:413
StringSubStringWithInt
const char * StringSubStringWithInt(string_t st, const char *str, u_int64_t z)
Definition: String.c:1438
BUFFSIZE
#define BUFFSIZE
Definition: String.c:1391
StringRemoveRight
const char * StringRemoveRight(string_t st, size_t x)
Definition: String.c:634
FACTOR
#define FACTOR
Definition: String.c:42
StringOwned
int StringOwned(string_t st)
Definition: String.c:86
StringRemoveDigits
const char * StringRemoveDigits(string_t st)
Definition: String.c:587
StringType::owned
int owned
Definition: String.c:66
StringCrop
const char * StringCrop(string_t st, size_t x, size_t y)
Definition: String.c:652
StringPointer
static const __inline__ char ** StringPointer(string_t st)
Definition: String.h:1006
StringAppend
const char * StringAppend(string_t st, const char *s)
Definition: String.c:1052
StringClear
void StringClear(string_t st)
Definition: String.c:618
StringSubString
const char * StringSubString(string_t st, size_t x, const char *s)
Definition: String.c:936
StringPrependMultipleString
const char * StringPrependMultipleString(string_t st,...)
Definition: String.c:1177
StringClearDelete
void StringClearDelete(string_t *st)
Definition: String.c:177
StringRemoveStringPos
const char * StringRemoveStringPos(string_t st, const char *s, size_t p)
Definition: String.c:1323
StringInsertCharChar
const char * StringInsertCharChar(string_t st, char x, char y)
Definition: String.c:1645
string_t
struct StringType * string_t
Definition: String.h:41
StringVoid
#define StringVoid
Definition: String.h:47