]> git.decadent.org.uk Git - dak.git/blob - tools/dsync-0.0/libdsync/contrib/strutl.cc
Add docs that the secret key only needs to be able to sign
[dak.git] / tools / dsync-0.0 / libdsync / contrib / strutl.cc
1 // -*- mode: cpp; mode: fold -*-
2 // Description                                                          /*{{{*/
3 // $Id: strutl.cc,v 1.4 1999/10/24 06:53:12 jgg Exp $
4 /* ######################################################################
5
6    String Util - Some usefull string functions.
7
8    These have been collected from here and there to do all sorts of usefull
9    things to strings. They are usefull in file parsers, URI handlers and
10    especially in APT methods.   
11    
12    This source is placed in the Public Domain, do with it what you will
13    It was originally written by Jason Gunthorpe <jgg@gpu.srv.ualberta.ca>
14    
15    ##################################################################### */
16                                                                         /*}}}*/
17 // Includes                                                             /*{{{*/
18 #ifdef __GNUG__
19 #pragma implementation "dsync/strutl.h"
20 #endif
21
22 #include <dsync/strutl.h>
23 #include <dsync/fileutl.h>
24
25 #include <ctype.h>
26 #include <string.h>
27 #include <stdio.h>
28 #include <unistd.h>
29 #include <errno.h>
30                                                                         /*}}}*/
31
32 // strstrip - Remove white space from the front and back of a string    /*{{{*/
33 // ---------------------------------------------------------------------
34 /* This is handy to use when parsing a file. It also removes \n's left 
35    over from fgets and company */
36 char *_strstrip(char *String)
37 {
38    for (;*String != 0 && (*String == ' ' || *String == '\t'); String++);
39
40    if (*String == 0)
41       return String;
42
43    char *End = String + strlen(String) - 1;
44    for (;End != String - 1 && (*End == ' ' || *End == '\t' || *End == '\n' ||
45                                *End == '\r'); End--);
46    End++;
47    *End = 0;
48    return String;
49 };
50                                                                         /*}}}*/
51 // strtabexpand - Converts tabs into 8 spaces                           /*{{{*/
52 // ---------------------------------------------------------------------
53 /* */
54 char *_strtabexpand(char *String,size_t Len)
55 {
56    for (char *I = String; I != I + Len && *I != 0; I++)
57    {
58       if (*I != '\t')
59          continue;
60       if (I + 8 > String + Len)
61       {
62          *I = 0;
63          return String;
64       }
65
66       /* Assume the start of the string is 0 and find the next 8 char
67          division */
68       int Len;
69       if (String == I)
70          Len = 1;
71       else
72          Len = 8 - ((String - I) % 8);
73       Len -= 2;
74       if (Len <= 0)
75       {
76          *I = ' ';
77          continue;
78       }
79       
80       memmove(I + Len,I + 1,strlen(I) + 1);
81       for (char *J = I; J + Len != I; *I = ' ', I++);
82    }
83    return String;
84 }
85                                                                         /*}}}*/
86 // ParseQuoteWord - Parse a single word out of a string                 /*{{{*/
87 // ---------------------------------------------------------------------
88 /* This grabs a single word, converts any % escaped characters to their
89    proper values and advances the pointer. Double quotes are understood
90    and striped out as well. This is for URI/URL parsing. */
91 bool ParseQuoteWord(const char *&String,string &Res)
92 {
93    // Skip leading whitespace
94    const char *C = String;
95    for (;*C != 0 && *C == ' '; C++);
96    if (*C == 0)
97       return false;
98    
99    // Jump to the next word
100    for (;*C != 0 && isspace(*C) == 0; C++)
101    {
102       if (*C == '"')
103       {
104          for (C++;*C != 0 && *C != '"'; C++);
105          if (*C == 0)
106             return false;
107       }
108    }
109
110    // Now de-quote characters
111    char Buffer[1024];
112    char Tmp[3];
113    const char *Start = String;
114    char *I;
115    for (I = Buffer; I < Buffer + sizeof(Buffer) && Start != C; I++)
116    {
117       if (*Start == '%' && Start + 2 < C)
118       {
119          Tmp[0] = Start[1];
120          Tmp[1] = Start[2];
121          Tmp[2] = 0;
122          *I = (char)strtol(Tmp,0,16);
123          Start += 3;
124          continue;
125       }
126       if (*Start != '"')
127          *I = *Start;
128       else
129          I--;
130       Start++;
131    }
132    *I = 0;
133    Res = Buffer;
134    
135    // Skip ending white space
136    for (;*C != 0 && isspace(*C) != 0; C++);
137    String = C;
138    return true;
139 }
140                                                                         /*}}}*/
141 // ParseCWord - Parses a string like a C "" expression                  /*{{{*/
142 // ---------------------------------------------------------------------
143 /* This expects a series of space seperated strings enclosed in ""'s. 
144    It concatenates the ""'s into a single string. */
145 bool ParseCWord(const char *String,string &Res)
146 {
147    // Skip leading whitespace
148    const char *C = String;
149    for (;*C != 0 && *C == ' '; C++);
150    if (*C == 0)
151       return false;
152    
153    char Buffer[1024];
154    char *Buf = Buffer;
155    if (strlen(String) >= sizeof(Buffer))
156        return false;
157        
158    for (; *C != 0; C++)
159    {
160       if (*C == '"')
161       {
162          for (C++; *C != 0 && *C != '"'; C++)
163             *Buf++ = *C;
164          
165          if (*C == 0)
166             return false;
167          
168          continue;
169       }      
170       
171       if (C != String && isspace(*C) != 0 && isspace(C[-1]) != 0)
172          continue;
173       if (isspace(*C) == 0)
174          return false;
175       *Buf++ = ' ';
176    }   
177    *Buf = 0;
178    Res = Buffer;
179    return true;
180 }
181                                                                         /*}}}*/
182 // QuoteString - Convert a string into quoted from                      /*{{{*/
183 // ---------------------------------------------------------------------
184 /* */
185 string QuoteString(string Str,const char *Bad)
186 {
187    string Res;
188    for (string::iterator I = Str.begin(); I != Str.end(); I++)
189    {
190       if (strchr(Bad,*I) != 0 || isprint(*I) == 0 || 
191           *I <= 0x20 || *I >= 0x7F)
192       {
193          char Buf[10];
194          sprintf(Buf,"%%%02x",(int)*I);
195          Res += Buf;
196       }
197       else
198          Res += *I;
199    }
200    return Res;
201 }
202                                                                         /*}}}*/
203 // DeQuoteString - Convert a string from quoted from                    /*{{{*/
204 // ---------------------------------------------------------------------
205 /* This undoes QuoteString */
206 string DeQuoteString(string Str)
207 {
208    string Res;
209    for (string::iterator I = Str.begin(); I != Str.end(); I++)
210    {
211       if (*I == '%' && I + 2 < Str.end())
212       {
213          char Tmp[3];
214          Tmp[0] = I[1];
215          Tmp[1] = I[2];
216          Tmp[2] = 0;
217          Res += (char)strtol(Tmp,0,16);
218          I += 2;
219          continue;
220       }
221       else
222          Res += *I;
223    }
224    return Res;   
225 }
226
227                                                                         /*}}}*/
228 // SizeToStr - Convert a long into a human readable size                /*{{{*/
229 // ---------------------------------------------------------------------
230 /* A max of 4 digits are shown before conversion to the next highest unit. 
231    The max length of the string will be 5 chars unless the size is > 10
232    YottaBytes (E24) */
233 string SizeToStr(double Size)
234 {
235    char S[300];
236    double ASize;
237    if (Size >= 0)
238       ASize = Size;
239    else
240       ASize = -1*Size;
241    
242    /* bytes, KiloBytes, MegaBytes, GigaBytes, TeraBytes, PetaBytes, 
243       ExaBytes, ZettaBytes, YottaBytes */
244    char Ext[] = {'\0','k','M','G','T','P','E','Z','Y'};
245    int I = 0;
246    while (I <= 8)
247    {
248       if (ASize < 100 && I != 0)
249       {
250          sprintf(S,"%.1f%c",ASize,Ext[I]);
251          break;
252       }
253       
254       if (ASize < 10000)
255       {
256          sprintf(S,"%.0f%c",ASize,Ext[I]);
257          break;
258       }
259       ASize /= 1000.0;
260       I++;
261    }
262    
263    return S;
264 }
265                                                                         /*}}}*/
266 // TimeToStr - Convert the time into a string                           /*{{{*/
267 // ---------------------------------------------------------------------
268 /* Converts a number of seconds to a hms format */
269 string TimeToStr(unsigned long Sec)
270 {
271    char S[300];
272    
273    while (1)
274    {
275       if (Sec > 60*60*24)
276       {
277          sprintf(S,"%lid %lih%lim%lis",Sec/60/60/24,(Sec/60/60) % 24,(Sec/60) % 60,Sec % 60);
278          break;
279       }
280       
281       if (Sec > 60*60)
282       {
283          sprintf(S,"%lih%lim%lis",Sec/60/60,(Sec/60) % 60,Sec % 60);
284          break;
285       }
286       
287       if (Sec > 60)
288       {
289          sprintf(S,"%lim%lis",Sec/60,Sec % 60);
290          break;
291       }
292       
293       sprintf(S,"%lis",Sec);
294       break;
295    }
296    
297    return S;
298 }
299                                                                         /*}}}*/
300 // SubstVar - Substitute a string for another string                    /*{{{*/
301 // ---------------------------------------------------------------------
302 /* This replaces all occurances of Subst with Contents in Str. */
303 string SubstVar(string Str,string Subst,string Contents)
304 {
305    string::size_type Pos = 0;
306    string::size_type OldPos = 0;
307    string Temp;
308    
309    while (OldPos < Str.length() && 
310           (Pos = Str.find(Subst,OldPos)) != string::npos)
311    {
312       Temp += string(Str,OldPos,Pos) + Contents;
313       OldPos = Pos + Subst.length();      
314    }
315    
316    if (OldPos == 0)
317       return Str;
318    
319    return Temp + string(Str,OldPos);
320 }
321                                                                         /*}}}*/
322 // URItoFileName - Convert the uri into a unique file name              /*{{{*/
323 // ---------------------------------------------------------------------
324 /* This converts a URI into a safe filename. It quotes all unsafe characters
325    and converts / to _ and removes the scheme identifier. The resulting
326    file name should be unique and never occur again for a different file */
327 string URItoFileName(string URI)
328 {
329    // Nuke 'sensitive' items
330    ::URI U(URI);
331    U.User = string();
332    U.Password = string();
333    U.Access = "";
334    
335    // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";
336    URI = QuoteString(U,"\\|{}[]<>\"^~_=!@#$%^&*");
337    string::iterator J = URI.begin();
338    for (; J != URI.end(); J++)
339       if (*J == '/') 
340          *J = '_';
341    return URI;
342 }
343                                                                         /*}}}*/
344 // Base64Encode - Base64 Encoding routine for short strings             /*{{{*/
345 // ---------------------------------------------------------------------
346 /* This routine performs a base64 transformation on a string. It was ripped
347    from wget and then patched and bug fixed.
348  
349    This spec can be found in rfc2045 */
350 string Base64Encode(string S)
351 {
352    // Conversion table.
353    static char tbl[64] = {'A','B','C','D','E','F','G','H',
354                           'I','J','K','L','M','N','O','P',
355                           'Q','R','S','T','U','V','W','X',
356                           'Y','Z','a','b','c','d','e','f',
357                           'g','h','i','j','k','l','m','n',
358                           'o','p','q','r','s','t','u','v',
359                           'w','x','y','z','0','1','2','3',
360                           '4','5','6','7','8','9','+','/'};
361    
362    // Pre-allocate some space
363    string Final;
364    Final.reserve((4*S.length() + 2)/3 + 2);
365
366    /* Transform the 3x8 bits to 4x6 bits, as required by
367       base64.  */
368    for (string::const_iterator I = S.begin(); I < S.end(); I += 3)
369    {
370       char Bits[3] = {0,0,0};
371       Bits[0] = I[0];
372       if (I + 1 < S.end())
373          Bits[1] = I[1];
374       if (I + 2 < S.end())
375          Bits[2] = I[2];
376
377       Final += tbl[Bits[0] >> 2];
378       Final += tbl[((Bits[0] & 3) << 4) + (Bits[1] >> 4)];
379       
380       if (I + 1 >= S.end())
381          break;
382       
383       Final += tbl[((Bits[1] & 0xf) << 2) + (Bits[2] >> 6)];
384       
385       if (I + 2 >= S.end())
386          break;
387       
388       Final += tbl[Bits[2] & 0x3f];
389    }
390
391    /* Apply the padding elements, this tells how many bytes the remote
392       end should discard */
393    if (S.length() % 3 == 2)
394       Final += '=';
395    if (S.length() % 3 == 1)
396       Final += "==";
397    
398    return Final;
399 }
400                                                                         /*}}}*/
401 // stringcmp - Arbitary string compare                                  /*{{{*/
402 // ---------------------------------------------------------------------
403 /* This safely compares two non-null terminated strings of arbitary 
404    length */
405 int stringcmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
406 {
407    for (; A != AEnd && B != BEnd; A++, B++)
408       if (*A != *B)
409          break;
410    
411    if (A == AEnd && B == BEnd)
412       return 0;
413    if (A == AEnd)
414       return 1;
415    if (B == BEnd)
416       return -1;
417    if (*A < *B)
418       return -1;
419    return 1;
420 }
421                                                                         /*}}}*/
422 // stringcasecmp - Arbitary case insensitive string compare             /*{{{*/
423 // ---------------------------------------------------------------------
424 /* */
425 int stringcasecmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
426 {
427    for (; A != AEnd && B != BEnd; A++, B++)
428       if (toupper(*A) != toupper(*B))
429          break;
430
431    if (A == AEnd && B == BEnd)
432       return 0;
433    if (A == AEnd)
434       return 1;
435    if (B == BEnd)
436       return -1;
437    if (toupper(*A) < toupper(*B))
438       return -1;
439    return 1;
440 }
441                                                                         /*}}}*/
442 // LookupTag - Lookup the value of a tag in a taged string              /*{{{*/
443 // ---------------------------------------------------------------------
444 /* The format is like those used in package files and the method 
445    communication system */
446 string LookupTag(string Message,const char *Tag,const char *Default)
447 {
448    // Look for a matching tag.
449    int Length = strlen(Tag);
450    for (string::iterator I = Message.begin(); I + Length < Message.end(); I++)
451    {
452       // Found the tag
453       const char *i = Message.c_str() + (I - Message.begin());
454       if (I[Length] == ':' && stringcasecmp(i,i+Length,Tag) == 0)
455       {
456          // Find the end of line and strip the leading/trailing spaces
457          string::iterator J;
458          I += Length + 1;
459          for (; isspace(*I) != 0 && I < Message.end(); I++);
460          for (J = I; *J != '\n' && J < Message.end(); J++);
461          for (; J > I && isspace(J[-1]) != 0; J--);
462          
463          return string(i,J-I);
464       }
465       
466       for (; *I != '\n' && I < Message.end(); I++);
467    }   
468    
469    // Failed to find a match
470    if (Default == 0)
471       return string();
472    return Default;
473 }
474                                                                         /*}}}*/
475 // StringToBool - Converts a string into a boolean                      /*{{{*/
476 // ---------------------------------------------------------------------
477 /* This inspects the string to see if it is true or if it is false and
478    then returns the result. Several varients on true/false are checked. */
479 int StringToBool(string Text,int Default)
480 {
481    char *End;
482    int Res = strtol(Text.c_str(),&End,0);   
483    if (End != Text.c_str() && Res >= 0 && Res <= 1)
484       return Res;
485    
486    // Check for positives
487    if (strcasecmp(Text.c_str(),"no") == 0 ||
488        strcasecmp(Text.c_str(),"false") == 0 ||
489        strcasecmp(Text.c_str(),"without") == 0 ||
490        strcasecmp(Text.c_str(),"off") == 0 ||
491        strcasecmp(Text.c_str(),"disable") == 0)
492       return 0;
493    
494    // Check for negatives
495    if (strcasecmp(Text.c_str(),"yes") == 0 ||
496        strcasecmp(Text.c_str(),"true") == 0 ||
497        strcasecmp(Text.c_str(),"with") == 0 ||
498        strcasecmp(Text.c_str(),"on") == 0 ||
499        strcasecmp(Text.c_str(),"enable") == 0)
500       return 1;
501    
502    return Default;
503 }
504                                                                         /*}}}*/
505 // TimeRFC1123 - Convert a time_t into RFC1123 format                   /*{{{*/
506 // ---------------------------------------------------------------------
507 /* This converts a time_t into a string time representation that is
508    year 2000 complient and timezone neutral */
509 string TimeRFC1123(time_t Date)
510 {
511    struct tm Conv = *gmtime(&Date);
512    char Buf[300];
513
514    const char *Day[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
515    const char *Month[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul",
516                           "Aug","Sep","Oct","Nov","Dec"};
517
518    sprintf(Buf,"%s, %02i %s %i %02i:%02i:%02i GMT",Day[Conv.tm_wday],
519            Conv.tm_mday,Month[Conv.tm_mon],Conv.tm_year+1900,Conv.tm_hour,
520            Conv.tm_min,Conv.tm_sec);
521    return Buf;
522 }
523                                                                         /*}}}*/
524 // ReadMessages - Read messages from the FD                             /*{{{*/
525 // ---------------------------------------------------------------------
526 /* This pulls full messages from the input FD into the message buffer. 
527    It assumes that messages will not pause during transit so no
528    fancy buffering is used. */
529 bool ReadMessages(int Fd, vector<string> &List)
530 {
531    char Buffer[4000];
532    char *End = Buffer;
533    
534    while (1)
535    {
536       int Res = read(Fd,End,sizeof(Buffer) - (End-Buffer));
537       if (Res < 0 && errno == EINTR)
538          continue;
539       
540       // Process is dead, this is kind of bad..
541       if (Res == 0)
542          return false;
543       
544       // No data
545       if (Res <= 0)
546          return true;
547
548       End += Res;
549       
550       // Look for the end of the message
551       for (char *I = Buffer; I + 1 < End; I++)
552       {
553          if (I[0] != '\n' || I[1] != '\n')
554             continue;
555          
556          // Pull the message out
557          string Message(Buffer,0,I-Buffer);
558
559          // Fix up the buffer
560          for (; I < End && *I == '\n'; I++);
561          End -= I-Buffer;        
562          memmove(Buffer,I,End-Buffer);
563          I = Buffer;
564          
565          List.push_back(Message);
566       }
567       if (End == Buffer)
568          return true;
569
570       if (WaitFd(Fd) == false)
571          return false;
572    }   
573 }
574                                                                         /*}}}*/
575 // MonthConv - Converts a month string into a number                    /*{{{*/
576 // ---------------------------------------------------------------------
577 /* This was lifted from the boa webserver which lifted it from 'wn-v1.07'
578    Made it a bit more robust with a few touppers though. */
579 static int MonthConv(char *Month)
580 {
581    switch (toupper(*Month)) 
582    {
583       case 'A':
584       return toupper(Month[1]) == 'P'?3:7;
585       case 'D':
586       return 11;
587       case 'F':
588       return 1;
589       case 'J':
590       if (toupper(Month[1]) == 'A')
591          return 0;
592       return toupper(Month[2]) == 'N'?5:6;
593       case 'M':
594       return toupper(Month[2]) == 'R'?2:4;
595       case 'N':
596       return 10;
597       case 'O':
598       return 9;
599       case 'S':
600       return 8;
601
602       // Pretend it is January..
603       default:
604       return 0;
605    }   
606 }
607                                                                         /*}}}*/
608 // timegm - Internal timegm function if gnu is not available            /*{{{*/
609 // ---------------------------------------------------------------------
610 /* Ripped this evil little function from wget - I prefer the use of 
611    GNU timegm if possible as this technique will have interesting problems
612    with leap seconds, timezones and other.
613    
614    Converts struct tm to time_t, assuming the data in tm is UTC rather
615    than local timezone (mktime assumes the latter).
616    
617    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
618    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO. */
619 #ifndef __USE_MISC        // glib sets this
620 static time_t timegm(struct tm *t)
621 {
622    time_t tl, tb;
623    
624    tl = mktime (t);
625    if (tl == -1)
626       return -1;
627    tb = mktime (gmtime (&tl));
628    return (tl <= tb ? (tl + (tl - tb)) : (tl - (tb - tl)));
629 }
630 #endif
631                                                                         /*}}}*/
632 // StrToTime - Converts a string into a time_t                          /*{{{*/
633 // ---------------------------------------------------------------------
634 /* This handles all 3 populare time formats including RFC 1123, RFC 1036
635    and the C library asctime format. It requires the GNU library function
636    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
637    reason the C library does not provide any such function :<*/
638 bool StrToTime(string Val,time_t &Result)
639 {
640    struct tm Tm;
641    char Month[10];
642    const char *I = Val.c_str();
643    
644    // Skip the day of the week
645    for (;*I != 0  && *I != ' '; I++);
646    
647    // Handle RFC 1123 time
648    if (sscanf(I," %d %3s %d %d:%d:%d GMT",&Tm.tm_mday,Month,&Tm.tm_year,
649               &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) != 6)
650    {
651       // Handle RFC 1036 time
652       if (sscanf(I," %d-%3s-%d %d:%d:%d GMT",&Tm.tm_mday,Month,
653                  &Tm.tm_year,&Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec) == 6)
654          Tm.tm_year += 1900;
655       else
656       {
657          // asctime format
658          if (sscanf(I," %3s %d %d:%d:%d %d",Month,&Tm.tm_mday,
659                     &Tm.tm_hour,&Tm.tm_min,&Tm.tm_sec,&Tm.tm_year) != 6)
660             return false;
661       }
662    }
663    
664    Tm.tm_isdst = 0;
665    Tm.tm_mon = MonthConv(Month);
666    Tm.tm_year -= 1900;
667    
668    // Convert to local time and then to GMT
669    Result = timegm(&Tm);
670    return true;
671 }
672                                                                         /*}}}*/
673 // StrToNum - Convert a fixed length string to a number                 /*{{{*/
674 // ---------------------------------------------------------------------
675 /* This is used in decoding the crazy fixed length string headers in 
676    tar and ar files. */
677 bool StrToNum(const char *Str,unsigned long &Res,unsigned Len,unsigned Base)
678 {
679    char S[30];
680    if (Len >= sizeof(S))
681       return false;
682    memcpy(S,Str,Len);
683    S[Len] = 0;
684    
685    // All spaces is a zero
686    Res = 0;
687    unsigned I;
688    for (I = 0; S[I] == ' '; I++);
689    if (S[I] == 0)
690       return true;
691    
692    char *End;
693    Res = strtoul(S,&End,Base);
694    if (End == S)
695       return false;
696    
697    return true;
698 }
699                                                                         /*}}}*/
700 // HexDigit - Convert a hex character into an integer                   /*{{{*/
701 // ---------------------------------------------------------------------
702 /* Helper for Hex2Num */
703 static int HexDigit(int c)
704 {   
705    if (c >= '0' && c <= '9')
706       return c - '0';
707    if (c >= 'a' && c <= 'f')
708       return c - 'a' + 10;
709    if (c >= 'A' && c <= 'F')
710       return c - 'A' + 10;
711    return 0;
712 }
713                                                                         /*}}}*/
714 // Hex2Num - Convert a long hex number into a buffer                    /*{{{*/
715 // ---------------------------------------------------------------------
716 /* The length of the buffer must be exactly 1/2 the length of the string. */
717 bool Hex2Num(const char *Start,const char *End,unsigned char *Num,
718              unsigned int Length)
719 {
720    if (End - Start != (signed)(Length*2))
721       return false;
722    
723    // Convert each digit. We store it in the same order as the string
724    int J = 0;
725    for (const char *I = Start; I < End;J++, I += 2)
726    {
727       if (isxdigit(*I) == 0 || isxdigit(I[1]) == 0)
728          return false;
729       
730       Num[J] = HexDigit(I[0]) << 4;
731       Num[J] += HexDigit(I[1]);
732    }
733    
734    return true;
735 }
736                                                                         /*}}}*/
737
738 // URI::CopyFrom - Copy from an object                                  /*{{{*/
739 // ---------------------------------------------------------------------
740 /* This parses the URI into all of its components */
741 void URI::CopyFrom(string U)
742 {
743    string::const_iterator I = U.begin();
744
745    // Locate the first colon, this seperates the scheme
746    for (; I < U.end() && *I != ':' ; I++);
747    string::const_iterator FirstColon = I;
748
749    /* Determine if this is a host type URI with a leading double //
750       and then search for the first single / */
751    string::const_iterator SingleSlash = I;
752    if (I + 3 < U.end() && I[1] == '/' && I[2] == '/')
753       SingleSlash += 3;
754    for (; SingleSlash < U.end() && *SingleSlash != '/'; SingleSlash++);
755    if (SingleSlash > U.end())
756       SingleSlash = U.end();
757
758    // We can now write the access and path specifiers
759    Access = string(U,0,FirstColon - U.begin());
760    if (SingleSlash != U.end())
761       Path = string(U,SingleSlash - U.begin());
762    if (Path.empty() == true)
763       Path = "/";
764
765    // Now we attempt to locate a user:pass@host fragment
766    if (FirstColon[1] == '/' && FirstColon[2] == '/')
767       FirstColon += 3;
768    else
769       FirstColon += 1;
770    if (FirstColon >= U.end())
771       return;
772    
773    if (FirstColon > SingleSlash)
774       FirstColon = SingleSlash;
775    
776    // Find the colon...
777    I = FirstColon + 1;
778    if (I > SingleSlash)
779       I = SingleSlash;
780    for (; I < SingleSlash && *I != ':'; I++);
781    string::const_iterator SecondColon = I;
782    
783    // Search for the @ after the colon
784    for (; I < SingleSlash && *I != '@'; I++);
785    string::const_iterator At = I;
786    
787    // Now write the host and user/pass
788    if (At == SingleSlash)
789    {
790       if (FirstColon < SingleSlash)
791          Host = string(U,FirstColon - U.begin(),SingleSlash - FirstColon);
792    }
793    else
794    {
795       Host = string(U,At - U.begin() + 1,SingleSlash - At - 1);
796       User = string(U,FirstColon - U.begin(),SecondColon - FirstColon);
797       if (SecondColon < At)
798          Password = string(U,SecondColon - U.begin() + 1,At - SecondColon - 1);
799    }   
800    
801    // Now we parse off a port number from the hostname
802    Port = 0;
803    string::size_type Pos = Host.rfind(':');
804    if (Pos == string::npos)
805       return;
806    
807    Port = atoi(string(Host,Pos+1).c_str());
808    Host = string(Host,0,Pos);
809 }
810                                                                         /*}}}*/
811 // URI::operator string - Convert the URI to a string                   /*{{{*/
812 // ---------------------------------------------------------------------
813 /* */
814 URI::operator string()
815 {
816    string Res;
817    
818    if (Access.empty() == false)
819       Res = Access + ':';
820    
821    if (Host.empty() == false)
822    {
823       if (Access.empty() == false)
824          Res += "//";
825       
826       if (User.empty() == false)
827       {
828          Res +=  User;
829          if (Password.empty() == false)
830             Res += ":" + Password;
831          Res += "@";
832       }
833       
834       Res += Host;
835       if (Port != 0)
836       {
837          char S[30];
838          sprintf(S,":%u",Port);
839          Res += S;
840       }  
841    }
842    
843    if (Path.empty() == false)
844    {
845       if (Path[0] != '/')
846          Res += "/" + Path;
847       else
848          Res += Path;
849    }
850    
851    return Res;
852 }
853                                                                         /*}}}*/