Annotation of Amaya/amaya/AHTURLTools.c, revision 1.39

1.7       cvs         1: /*
                      2:  *
                      3:  *  (c) COPYRIGHT MIT and INRIA, 1996.
                      4:  *  Please first read the full copyright statement in file COPYRIGHT.
                      5:  *
                      6:  */
1.9       cvs         7: 
1.10      cvs         8: /*
                      9:  * AHTURLTools.c: contains all the functions for testing, manipulating,
1.25      cvs        10:  * and normalizing URLs. It also contains a local copy of the libWWW
                     11:  * URL parsing functions.
1.10      cvs        12:  *
                     13:  * Authors: J. Kahan, I. Vatton
                     14:  *
                     15:  */
1.7       cvs        16:  
1.15      cvs        17: #define THOT_EXPORT extern
1.3       cvs        18: #include "amaya.h"
                     19: 
1.8       cvs        20: #include "init_f.h"
                     21: #include "AHTURLTools_f.h"
                     22: 
1.24      cvs        23: #define MAX_PRINT_URL_LENGTH 50
1.29      cvs        24: typedef struct _HTURI {
                     25:     char * access;             /* Now known as "scheme" */
                     26:     char * host;
                     27:     char * absolute;
                     28:     char * relative;
                     29:     char * fragment;
                     30: } HTURI;
1.24      cvs        31: 
1.28      cvs        32: 
                     33: /*----------------------------------------------------------------------
                     34:   ConvertToLowerCase
                     35:   Converts a string to lowercase.
                     36:   ----------------------------------------------------------------------*/
1.22      cvs        37: #ifdef __STDC__
1.38      cvs        38: void         ConvertToLowerCase (char *string)
1.28      cvs        39: #else  /* __STDC__ */
1.38      cvs        40: void         ConvertToLowerCase (string)
1.28      cvs        41: char                *string;
                     42: 
                     43: #endif /* __STDC__ */
                     44: {
                     45:  int i;
                     46: 
                     47:  if (!string)
                     48:    return;
                     49: 
                     50:  for (i = 0; string[i] != EOS; i++)
                     51:    string[i] = tolower (string[i]);
                     52: }
1.22      cvs        53: 
1.8       cvs        54: /*----------------------------------------------------------------------
1.11      cvs        55:   ExplodeURL 
1.8       cvs        56:   ----------------------------------------------------------------------*/
                     57: #ifdef __STDC__
                     58: void                ExplodeURL (char *url, char **proto, char **host, char **dir, char **file)
                     59: #else
                     60: void                ExplodeURL (url, proto, host, dir, file)
                     61: char               *url;
                     62: char              **proto;
                     63: char              **host;
                     64: char              **dir;
                     65: char              **file;
                     66: 
                     67: #endif
                     68: {
1.33      cvs        69:    char            *curr, *temp;
                     70:    char             used_sep;
1.32      cvs        71: 
1.33      cvs        72:    if (url && strchr (url, URL_SEP))
                     73:      used_sep = URL_SEP;
                     74:    else
                     75:      used_sep = DIR_SEP;
1.8       cvs        76: 
                     77:    if ((url == NULL) || (proto == NULL) || (host == NULL) ||
                     78:        (dir == NULL) || (file == NULL))
                     79:       return;
                     80: 
                     81:    /* initialize every pointer */
                     82:    *proto = *host = *dir = *file = NULL;
                     83: 
                     84:    /* skip any leading space */
                     85:    while ((*url == SPACE) || (*url == TAB))
                     86:       url++;
1.9       cvs        87:    curr = url;
                     88:    if (*curr == 0)
1.8       cvs        89:       goto finished;
                     90: 
                     91:    /* go to the end of the URL */
1.9       cvs        92:    while ((*curr != 0) && (*curr != SPACE) && (*curr != '\b') &&
                     93:          (*curr != '\r') && (*curr != EOL))
                     94:       curr++;
1.8       cvs        95: 
                     96:    /* mark the end of the chain */
1.9       cvs        97:    *curr = EOS;
                     98:    curr--;
                     99:    if (curr <= url)
1.8       cvs       100:       goto finished;
                    101: 
                    102:    /* search the next DIR_SEP indicating the beginning of the file name */
                    103:    do
1.11      cvs       104:      curr--;
1.33      cvs       105:    while ((curr >= url) && (*curr != used_sep));
1.11      cvs       106: 
1.9       cvs       107:    if (curr < url)
1.8       cvs       108:       goto finished;
1.9       cvs       109:    *file = curr + 1;
1.8       cvs       110: 
                    111:    /* mark the end of the dir */
1.9       cvs       112:    *curr = EOS;
                    113:    curr--;
                    114:    if (curr < url)
1.8       cvs       115:       goto finished;
                    116: 
1.29      cvs       117:    /* search for the DIR_STR indicating the host name start */
1.33      cvs       118:    while ((curr > url) && ((*curr != used_sep) || (*(curr + 1) != used_sep)))
1.9       cvs       119:       curr--;
1.8       cvs       120: 
                    121:    /* if we found it, separate the host name from the directory */
1.33      cvs       122:    if ((*curr == DIR_SEP) && (*(curr + 1) == used_sep))
1.8       cvs       123:      {
1.9       cvs       124:        *host = temp = curr + 2;
1.33      cvs       125:        while ((*temp != 0) && (*temp != used_sep))
1.8       cvs       126:           temp++;
1.33      cvs       127:        if (*temp == used_sep)
1.8       cvs       128:          {
                    129:             *temp = EOS;
                    130:             *dir = temp + 1;
                    131:          }
                    132:      }
                    133:    else
1.11      cvs       134:      *dir = curr;
                    135: 
1.9       cvs       136:    if (curr <= url)
1.8       cvs       137:       goto finished;
                    138: 
                    139:    /* mark the end of the proto */
1.9       cvs       140:    *curr = EOS;
                    141:    curr--;
                    142:    if (curr < url)
1.8       cvs       143:       goto finished;
                    144: 
1.32      cvs       145:    if (*curr == ':')
1.8       cvs       146:      {
1.9       cvs       147:        *curr = EOS;
                    148:        curr--;
1.8       cvs       149:      }
                    150:    else
                    151:       goto finished;
1.11      cvs       152: 
1.9       cvs       153:    if (curr < url)
1.8       cvs       154:       goto finished;
1.9       cvs       155:    while ((curr > url) && (isalpha (*curr)))
                    156:       curr--;
                    157:    *proto = curr;
1.8       cvs       158: 
                    159:  finished:;
                    160: 
                    161: #ifdef AMAYA_DEBUG
                    162:    fprintf (stderr, "ExplodeURL(%s)\n\t", url);
                    163:    if (*proto)
                    164:       fprintf (stderr, "proto : %s, ", *proto);
                    165:    if (*host)
                    166:       fprintf (stderr, "host : %s, ", *host);
                    167:    if (*dir)
                    168:       fprintf (stderr, "dir : %s, ", *dir);
                    169:    if (*file)
                    170:       fprintf (stderr, "file : %s ", *file);
                    171:    fprintf (stderr, "\n");
                    172: #endif
                    173: 
                    174: }
1.3       cvs       175: 
1.4       cvs       176: /*----------------------------------------------------------------------
1.9       cvs       177:   IsHTMLName                                                         
                    178:   returns TRUE if path points to an HTML resource.
1.4       cvs       179:   ----------------------------------------------------------------------*/
1.3       cvs       180: #ifdef __STDC__
1.34      cvs       181: boolean             IsHTMLName (const char *path)
1.3       cvs       182: #else  /* __STDC__ */
                    183: boolean             IsHTMLName (path)
1.34      cvs       184: const char         *path;
1.3       cvs       185: #endif /* __STDC__ */
                    186: {
1.5       cvs       187:    char                temppath[MAX_LENGTH];
                    188:    char                suffix[MAX_LENGTH];
                    189:    char                nsuffix[MAX_LENGTH];
                    190:    int                 i;
                    191: 
                    192:    if (!path)
1.37      cvs       193:       return (FALSE);
1.5       cvs       194: 
                    195:    strcpy (temppath, path);
                    196:    ExtractSuffix (temppath, suffix);
                    197: 
                    198:    /* Normalize the suffix */
                    199:    i = 0;
1.39    ! cvs       200:    while (suffix[i] != EOS && i < MAX_LENGTH -1)
1.13      cvs       201:      {
1.25      cvs       202:        nsuffix[i] = tolower (suffix[i]);
1.13      cvs       203:        i++;
                    204:      }
1.5       cvs       205:    nsuffix[i] = EOS;
1.39    ! cvs       206:    if ((!strcmp (nsuffix, "html")) ||
        !           207:        (!strcmp (nsuffix, "htm")) ||
        !           208:        (!strcmp (nsuffix, "shtml")))
        !           209:      return (TRUE);
1.22      cvs       210:    else if (!strcmp (nsuffix, "gz"))
1.13      cvs       211:      {
1.39    ! cvs       212:        /* take into account compressed files */
1.13      cvs       213:        ExtractSuffix (temppath, suffix);       
                    214:        /* Normalize the suffix */
                    215:        i = 0;
1.39    ! cvs       216:        while (suffix[i] != EOS && i < MAX_LENGTH -1)
1.13      cvs       217:         {
1.25      cvs       218:           nsuffix[i] = tolower (suffix[i]);
1.13      cvs       219:           i++;
                    220:         }
                    221:        nsuffix[i] = EOS;
1.39    ! cvs       222:        if ((!strcmp (nsuffix, "html")) ||
        !           223:           (!strcmp (nsuffix, "htm")) ||
        !           224:           (!strcmp (nsuffix, "shtml")))
        !           225:         return (TRUE);
        !           226:        else
1.13      cvs       227:         return (FALSE);
                    228:      }
                    229:    else
1.39    ! cvs       230:      return (FALSE);
1.3       cvs       231: }
                    232: 
1.4       cvs       233: /*----------------------------------------------------------------------
1.9       cvs       234:   IsImageName                                
                    235:   returns TRUE if path points to an image resource.
1.4       cvs       236:   ----------------------------------------------------------------------*/
1.3       cvs       237: #ifdef __STDC__
1.34      cvs       238: boolean             IsImageName (const char *path)
1.3       cvs       239: #else  /* __STDC__ */
                    240: boolean             IsImageName (path)
1.34      cvs       241: const char         *path;
1.3       cvs       242: #endif /* __STDC__ */
                    243: {
1.5       cvs       244:    char                temppath[MAX_LENGTH];
                    245:    char                suffix[MAX_LENGTH];
                    246:    char                nsuffix[MAX_LENGTH];
                    247:    int                 i;
                    248: 
                    249:    if (!path)
1.13      cvs       250:       return (FALSE);
1.5       cvs       251: 
                    252:    strcpy (temppath, path);
                    253:    ExtractSuffix (temppath, suffix);
                    254: 
                    255:    /* Normalize the suffix */
                    256:    i = 0;
1.39    ! cvs       257:    while (suffix[i] != EOS && i < MAX_LENGTH -1)
1.13      cvs       258:      {
1.25      cvs       259:        nsuffix[i] = tolower (suffix[i]);
1.13      cvs       260:        i++;
                    261:      }
1.5       cvs       262:    nsuffix[i] = EOS;
1.39    ! cvs       263:    if ((!strcmp (nsuffix, "gif")) || (!strcmp (nsuffix, "xbm")) ||
        !           264:        (!strcmp (nsuffix, "xpm")) || (!strcmp (nsuffix, "jpg")) ||
        !           265:        (!strcmp (nsuffix, "png")) || (!strcmp (nsuffix, "au")))
        !           266:       return (TRUE);
        !           267:    return (FALSE);
1.3       cvs       268: }
                    269: 
1.4       cvs       270: /*----------------------------------------------------------------------
1.9       cvs       271:   IsTextName                                                         
1.4       cvs       272:   ----------------------------------------------------------------------*/
1.3       cvs       273: #ifdef __STDC__
1.34      cvs       274: boolean             IsTextName (const char *path)
1.3       cvs       275: #else  /* __STDC__ */
                    276: boolean             IsTextName (path)
1.34      cvs       277: const char         *path;
1.3       cvs       278: 
                    279: #endif /* __STDC__ */
                    280: {
1.5       cvs       281:    char                temppath[MAX_LENGTH];
                    282:    char                suffix[MAX_LENGTH];
                    283:    char                nsuffix[MAX_LENGTH];
                    284:    int                 i;
                    285: 
                    286:    if (!path)
1.13      cvs       287:      return (FALSE);
1.5       cvs       288: 
                    289:    strcpy (temppath, path);
                    290:    ExtractSuffix (temppath, suffix);
                    291: 
                    292:    /* Normalize the suffix */
                    293:    i = 0;
1.39    ! cvs       294:    while (suffix[i] != EOS && i < MAX_LENGTH -1)
1.5       cvs       295:      {
1.25      cvs       296:        nsuffix[i] = tolower (suffix[i]);
1.5       cvs       297:        i++;
                    298:      }
                    299:    nsuffix[i] = EOS;
                    300: 
1.39    ! cvs       301:    if ((!strcmp (nsuffix, "txt")) || (!strcmp (nsuffix, "dtd")))
1.13      cvs       302:       return (TRUE);
1.22      cvs       303:    else if (!strcmp (nsuffix, "gz"))
1.13      cvs       304:      {
1.39    ! cvs       305:        /* take into account compressed files */
1.13      cvs       306:        ExtractSuffix (temppath, suffix);       
                    307:        /* Normalize the suffix */
                    308:        i = 0;
1.39    ! cvs       309:        while (suffix[i] != EOS && i < MAX_LENGTH -1)
1.13      cvs       310:         {
1.25      cvs       311:           nsuffix[i] = tolower (suffix[i]);
1.13      cvs       312:           i++;
                    313:         }
                    314:        nsuffix[i] = EOS;
1.39    ! cvs       315:        if ((!strcmp (nsuffix, "txt")) || (!strcmp (nsuffix, "dtd")))
1.13      cvs       316:         return (TRUE);
                    317:        else
                    318:         return (FALSE);
                    319:      }
                    320:    else
                    321:      return (FALSE);
1.3       cvs       322: }
                    323: 
1.4       cvs       324: /*----------------------------------------------------------------------
1.9       cvs       325:   IsHTTPPath                                     
                    326:   returns TRUE if path is in fact an http URL.
1.4       cvs       327:   ----------------------------------------------------------------------*/
1.3       cvs       328: #ifdef __STDC__
1.34      cvs       329: boolean             IsHTTPPath (const char *path)
1.3       cvs       330: #else  /* __STDC__ */
                    331: boolean             IsHTTPPath (path)
1.34      cvs       332: const char         *path;
1.3       cvs       333: #endif /* __STDC__ */
                    334: {
1.5       cvs       335:    if (!path)
                    336:       return FALSE;
1.3       cvs       337: 
1.5       cvs       338:    if (strncmp (path, "http:", 5) != 0)
                    339:       return FALSE;
                    340:    return TRUE;
1.3       cvs       341: }
                    342: 
1.4       cvs       343: /*----------------------------------------------------------------------
1.9       cvs       344:   IsWithParameters                           
                    345:   returns TRUE if url has a concatenated query string.
1.4       cvs       346:   ----------------------------------------------------------------------*/
1.3       cvs       347: #ifdef __STDC__
1.34      cvs       348: boolean             IsWithParameters (const char *url)
1.3       cvs       349: #else  /* __STDC__ */
1.9       cvs       350: boolean             IsWithParameters (url)
1.34      cvs       351: const char         *url;
1.3       cvs       352: #endif /* __STDC__ */
                    353: {
1.5       cvs       354:    int                 i;
1.3       cvs       355: 
1.9       cvs       356:    if ((!url) || (url[0] == EOS))
1.5       cvs       357:       return FALSE;
1.3       cvs       358: 
1.9       cvs       359:    i = strlen (url) - 1;
                    360:    while (i > 0 && url[i--] != '?')
1.5       cvs       361:       if (i < 0)
                    362:         return FALSE;
1.3       cvs       363: 
1.5       cvs       364:    /* There is a parameter */
                    365:    return TRUE;
1.3       cvs       366: }
                    367: 
1.4       cvs       368: /*----------------------------------------------------------------------
1.9       cvs       369:   IsW3Path                                           
                    370:   returns TRUE if path is in fact a URL.
1.4       cvs       371:   ----------------------------------------------------------------------*/
1.3       cvs       372: #ifdef __STDC__
1.34      cvs       373: boolean             IsW3Path (const char *path)
1.3       cvs       374: #else  /* __STDC__ */
                    375: boolean             IsW3Path (path)
1.34      cvs       376: const char               *path;
1.3       cvs       377: #endif /* __STDC__ */
                    378: {
1.5       cvs       379:    if ((strncmp (path, "http:", 5)) && (strncmp (path, "ftp:", 4)) &&
                    380:        (strncmp (path, "telnet:", 7)) && (strncmp (path, "wais:", 5)) &&
                    381:        (strncmp (path, "news:", 5)) && (strncmp (path, "gopher:", 7)) &&
                    382:        (strncmp (path, "mailto:", 7)) && (strncmp (path, "archie:", 7)))
                    383:       return FALSE;
                    384:    return TRUE;
1.3       cvs       385: }
                    386: 
1.4       cvs       387: /*----------------------------------------------------------------------
1.9       cvs       388:   IsValidProtocol                                                    
                    389:   returns true if the url protocol is supported by Amaya.
1.4       cvs       390:   ----------------------------------------------------------------------*/
1.3       cvs       391: #ifdef __STDC__
1.34      cvs       392: boolean             IsValidProtocol (const char *url)
1.3       cvs       393: #else  /* __STDC__ */
1.9       cvs       394: boolean             IsValidProtocol (url)
1.34      cvs       395: const char         *url;
1.3       cvs       396: #endif /* __STDC__ */
                    397: {
1.26      cvs       398:    if (!strncmp (url, "http:", 5))
1.22      cvs       399:        /* experimental */
1.26      cvs       400:       /***  || !strncmp (url, "ftp:", 4)) ***/
1.24      cvs       401:      /*** || !strncmp (path, "news:", 5)***/ 
1.8       cvs       402:       return (TRUE);
1.5       cvs       403:    else
1.8       cvs       404:       return (FALSE);
1.3       cvs       405: }
                    406: 
1.31      cvs       407: 
                    408: /*----------------------------------------------------------------------
                    409:    GetBaseURL
                    410:    normalizes orgName according to a base associated with doc, and
                    411:    following the standard URL format rules.
                    412:    The function returns the base used to solve relative URL and SRC:
                    413:       - the base of the document,
                    414:       - or the document path (without document name).
                    415:   ----------------------------------------------------------------------*/
                    416: #ifdef __STDC__
                    417: char               *GetBaseURL (Document doc)
                    418: #else  /* __STDC__ */
                    419: char               *GetBaseURL (doc)
                    420: Document            doc;
                    421: #endif /* __STDC__ */
                    422: {
                    423:   Element             el;
                    424:   ElementType         elType;
                    425:   AttributeType       attrType;
                    426:   Attribute           attr;
1.34      cvs       427:   char                used_sep = URL_SEP;
1.33      cvs       428:   char               *used_str;
1.31      cvs       429:   char               *ptr, *basename;
                    430:   int                 length;
                    431: 
                    432:   basename = TtaGetMemory (MAX_LENGTH);
1.39    ! cvs       433:   strncpy (basename, DocumentURLs[doc], MAX_LENGTH-1);
        !           434:   basename[MAX_LENGTH-1] = EOS;
1.31      cvs       435:   length = MAX_LENGTH -1;
                    436:   /* get the root element    */
                    437:   el = TtaGetMainRoot (doc);
                    438:   /* search the BASE element */
                    439:   elType.ElSSchema = TtaGetDocumentSSchema (doc);
                    440:   elType.ElTypeNum = HTML_EL_BASE;
                    441:   el = TtaSearchTypedElement (elType, SearchInTree, el);
                    442:   if (el)
                    443:     {
                    444:       /*  The document has a BASE element -> Get the HREF attribute */
                    445:       attrType.AttrSSchema = elType.ElSSchema;
                    446:       attrType.AttrTypeNum = HTML_ATTR_HREF_;
                    447:       attr = TtaGetAttribute (el, attrType);
                    448:       if (attr)
                    449:        {
                    450:          /* Use the base path of the document */
                    451:          TtaGiveTextAttributeValue (attr, basename, &length);
                    452:          /* base and orgName have to be separated by a DIR_SEP */
                    453:          length--;
1.32      cvs       454: 
1.33      cvs       455:          if (basename [0] != EOS && strchr (basename, URL_SEP))
                    456:            {
                    457:              used_str = URL_STR;
                    458:              used_sep = URL_SEP;
                    459:            }
                    460:          else
                    461:            {
                    462:              used_str = DIR_STR;
                    463:              used_sep = DIR_SEP;
                    464:            }
1.32      cvs       465: 
1.33      cvs       466:          if (basename[0] != EOS && basename[length] != used_sep) 
1.31      cvs       467:            /* verify if the base has the form "protocol://server:port" */
                    468:            {
1.33      cvs       469:              ptr = AmayaParseUrl (basename, "", AMAYA_PARSE_ACCESS |
                    470:                                                 AMAYA_PARSE_HOST |
                    471:                                                 AMAYA_PARSE_PUNCTUATION);
1.31      cvs       472:              if (ptr && !strcmp (ptr, basename))
                    473:                {
                    474:                  /* it has this form, we complete it by adding a DIR_STR  */
1.33      cvs       475:                  strcat (basename, used_str);
1.31      cvs       476:                  length++;
                    477:                }
                    478:              if (ptr)
                    479:                TtaFreeMemory (ptr);
                    480:            }
                    481:        }
1.33      cvs       482:       }
1.32      cvs       483:     else
1.33      cvs       484:       {
                    485:        if (basename [0] != EOS && strchr (basename, URL_SEP))
                    486:          {
                    487:            used_str = URL_STR;
                    488:            used_sep = URL_SEP;
                    489:          }
                    490:        else
                    491:          {
                    492:            used_str = DIR_STR;
                    493:            used_sep = DIR_SEP;
                    494:          }
                    495:       }
                    496:   
1.31      cvs       497:   /* Remove anything after the last DIR_SEP char. If no such char is found,
                    498:    * then search for the first ":" char, hoping that what's before that is a
                    499:    * protocol. If found, end the string there. If neither char is found,
                    500:    * then discard the whole base element.
                    501:    */
                    502:   length = strlen (basename) - 1;
                    503:   /* search for the last DIR_SEP char */
1.33      cvs       504:   while (length >= 0  && basename[length] != used_sep)
1.31      cvs       505:     length--;
                    506:   if (length >= 0)
                    507:     /* found the last DIR_SEP char, end the string there */
                    508:     basename[length + 1] = EOS;                   
                    509:   else
                    510:     /* search for the first PATH_STR char */
                    511:     {
1.32      cvs       512:       for (length = 0; basename[length] != ':' && 
1.31      cvs       513:             basename[length] != EOS; length ++);
1.32      cvs       514:       if (basename[length] == ':')
1.31      cvs       515:        /* found, so end the string there */
                    516:        basename[length + 1] = EOS;
                    517:       else
                    518:        /* not found, discard the base */
                    519:        basename[0] = EOS;
                    520:     }
                    521:   return (basename);
                    522: }
                    523: 
                    524: 
1.4       cvs       525: /*----------------------------------------------------------------------
1.9       cvs       526:    NormalizeURL
                    527:    normalizes orgName according to a base associated with doc, and
                    528:    following the standard URL format rules.
                    529:    The function returns the new complete and normalized URL 
1.12      cvs       530:    or file name path (newName) and the name of the document (docName).        
1.9       cvs       531:    N.B. If the function can't find out what's the docName, it assigns
                    532:    the name "noname.html".
1.4       cvs       533:   ----------------------------------------------------------------------*/
1.3       cvs       534: #ifdef __STDC__
                    535: void                NormalizeURL (char *orgName, Document doc, char *newName, char *docName)
                    536: #else  /* __STDC__ */
                    537: void                NormalizeURL (orgName, doc, newName, docName)
                    538: char               *orgName;
                    539: Document            doc;
                    540: char               *newName;
                    541: char               *docName;
                    542: #endif /* __STDC__ */
                    543: {
1.31      cvs       544:    char               *basename;
1.18      cvs       545:    char                tempOrgName[MAX_LENGTH];
1.5       cvs       546:    char               *ptr;
                    547:    int                 length;
1.33      cvs       548:    char                used_sep;
                    549:    char               *used_str;
1.5       cvs       550: 
                    551:    if (!newName || !docName)
                    552:       return;
1.18      cvs       553: 
1.32      cvs       554:    if (doc != 0)
1.33      cvs       555:      basename = GetBaseURL (doc);
1.32      cvs       556:    else
1.33      cvs       557:      basename = (char *) NULL;
1.32      cvs       558: 
1.33      cvs       559:    if (strchr (orgName, URL_SEP) || (basename && strchr (basename, URL_SEP)))
                    560:      { 
                    561:        used_str = URL_STR;
                    562:        used_sep = URL_SEP;
                    563:      }
                    564:    else
                    565:      {
                    566:        used_str = DIR_STR;
                    567:        used_sep = DIR_SEP;
                    568:      }
1.32      cvs       569: 
1.18      cvs       570:    /*
1.31      cvs       571:     * Clean orgName
                    572:     * Make sure we have a complete orgName, without any leading or trailing
                    573:     * white spaces, or trailinbg new lines
                    574:     */
1.18      cvs       575: 
1.5       cvs       576:    ptr = orgName;
1.18      cvs       577:    /* skip leading white space and new line characters */
1.19      cvs       578:    while ((*ptr == ' ' || *ptr == EOL) && *ptr++ != EOS);
1.39    ! cvs       579:    strncpy (tempOrgName, ptr, MAX_LENGTH -1);
        !           580:    tempOrgName[MAX_LENGTH -1] = EOS;
1.18      cvs       581:    /* clean trailing white space */
                    582:    ptr = strchr (tempOrgName, ' ');
                    583:    if (ptr)
                    584:       *ptr = EOS;
                    585:    /* clean trailing new lines */
1.19      cvs       586:    ptr = strchr (tempOrgName, EOL);
1.5       cvs       587:    if (ptr)
                    588:       *ptr = EOS;
                    589: 
1.18      cvs       590:    /*
1.31      cvs       591:     * Make orgName a complete URL
                    592:     * If the URL does not include a protocol, then try to calculate
                    593:     * one using the doc's base element (if it exists),
                    594:     */
1.21      cvs       595:    if (tempOrgName[0] == EOS)
                    596:      {
                    597:        newName[0] = EOS;
1.36      cvs       598:        TtaFreeMemory (basename);
1.21      cvs       599:        return;
                    600:      }
                    601:    else if (IsW3Path (tempOrgName))
                    602:      {
                    603:        /* the name is complete, go to the Sixth Step */
                    604:        strcpy (newName, tempOrgName);
                    605:        /* verify if the URL has the form "protocol://server:port" */
1.25      cvs       606:        ptr = AmayaParseUrl (newName, "", AMAYA_PARSE_ACCESS | AMAYA_PARSE_HOST |
                    607:                      AMAYA_PARSE_PUNCTUATION);
1.21      cvs       608:        if (ptr && !strcmp (ptr, newName))
                    609:         {
1.29      cvs       610:           /* it has this form, we complete it by adding a DIR_STR  */
1.33      cvs       611:           strcat (newName, used_str);
1.21      cvs       612:         }
                    613:        if (ptr)
1.25      cvs       614:         TtaFreeMemory (ptr);
1.21      cvs       615:      }
                    616:    else if ( doc == 0)
1.19      cvs       617:      /* the name is complete, go to the Sixth Step */
1.18      cvs       618:      strcpy (newName, tempOrgName);
1.5       cvs       619:    else
                    620:      {
1.22      cvs       621:      
1.31      cvs       622:        /* Calculate the absolute URL, using the base or document URL */
1.32      cvs       623: 
1.25      cvs       624:        ptr = AmayaParseUrl (tempOrgName, basename, AMAYA_PARSE_ALL);
1.14      cvs       625:        if (ptr)
                    626:         {
1.29      cvs       627:           SimplifyUrl (&ptr);
1.14      cvs       628:           strcpy (newName, ptr);
1.25      cvs       629:           TtaFreeMemory (ptr);
1.14      cvs       630:         }
                    631:        else
1.18      cvs       632:           newName[0] = EOS;
1.5       cvs       633:      }
1.36      cvs       634: 
                    635:    TtaFreeMemory (basename);
1.5       cvs       636: 
1.18      cvs       637:    /*
1.31      cvs       638:     * Prepare the docname that will refer to this ressource in the
                    639:     * .amaya directory. If the new URL finishes on DIR_SEP, then use
                    640:     * noname.html as a default ressource name
1.18      cvs       641:    */
1.19      cvs       642:    if (newName[0] != EOS)
1.5       cvs       643:      {
1.19      cvs       644:        length = strlen (newName) - 1;
1.33      cvs       645:        if (newName[length] == used_sep)
1.18      cvs       646:         {
                    647:           /* docname was not comprised inside the URL, so let's */
                    648:           /* assign the default ressource name */
                    649:           strcpy (docName, "noname.html");
                    650:           /* remove DIR_SEP at the end of complete path */
1.23      cvs       651:           /* newName[length] = EOS; */
1.18      cvs       652:         }
1.14      cvs       653:        else
1.18      cvs       654:         {
                    655:           /* docname is comprised inside the URL */
1.33      cvs       656:           while (length >= 0  && newName[length] != used_sep)
1.18      cvs       657:             length--;
                    658:           if (length < 0)
                    659:             strcpy (docName, newName);
                    660:           else
                    661:             strcpy (docName, &newName[length+1]);
                    662:         }
1.19      cvs       663: 
1.5       cvs       664:      }
1.18      cvs       665:    else
                    666:      docName[0] = EOS;
                    667: } 
1.3       cvs       668: 
1.4       cvs       669: /*----------------------------------------------------------------------
1.9       cvs       670:   IsSameHost                                                         
1.4       cvs       671:   ----------------------------------------------------------------------*/
1.3       cvs       672: #ifdef __STDC__
1.34      cvs       673: boolean             IsSameHost (const char *url1, const char *url2)
1.3       cvs       674: #else  /* __STDC__ */
                    675: boolean             IsSameHost (url1, url2)
1.34      cvs       676: const char         *url1;
                    677: const char         *url2;
1.3       cvs       678: #endif /* __STDC__ */
                    679: {
1.34      cvs       680:    char            *basename_ptr1, *basename_ptr2;
                    681:    boolean          result;
1.3       cvs       682: 
1.25      cvs       683:    basename_ptr1 = AmayaParseUrl (url1, "", AMAYA_PARSE_ACCESS | AMAYA_PARSE_HOST | AMAYA_PARSE_PUNCTUATION);
                    684:    basename_ptr2 = AmayaParseUrl (url2, "", AMAYA_PARSE_ACCESS | AMAYA_PARSE_HOST | AMAYA_PARSE_PUNCTUATION);
1.3       cvs       685: 
1.5       cvs       686:    if (strcmp (basename_ptr1, basename_ptr2))
1.8       cvs       687:       result = FALSE;
1.5       cvs       688:    else
1.8       cvs       689:       result = TRUE;
1.3       cvs       690: 
1.25      cvs       691:    TtaFreeMemory (basename_ptr1);
                    692:    TtaFreeMemory (basename_ptr2);
1.5       cvs       693:    return (result);
1.3       cvs       694: }
                    695: 
                    696: 
1.4       cvs       697: /*----------------------------------------------------------------------
1.22      cvs       698:   HasKnownFileSuffix
                    699:   returns TRUE if path points to a file ending with a suffix.
                    700:   ----------------------------------------------------------------------*/
                    701: #ifdef __STDC__
1.34      cvs       702: boolean             HasKnownFileSuffix (const char *path)
1.22      cvs       703: #else  /* __STDC__ */
                    704: boolean             HasKnownFileSuffix (path)
1.34      cvs       705: const char         *path;
1.22      cvs       706: #endif /* __STDC__ */
                    707: {
1.29      cvs       708:    char            *root;
                    709:    char             temppath[MAX_LENGTH];
                    710:    char             suffix[MAX_LENGTH];
1.22      cvs       711: 
1.24      cvs       712:    if (!path || path[0] == EOS || path[strlen(path)] == DIR_SEP)
1.22      cvs       713:      return (FALSE);
                    714: 
1.29      cvs       715:    root = AmayaParseUrl(path, "", AMAYA_PARSE_PATH | AMAYA_PARSE_PUNCTUATION);
1.22      cvs       716: 
                    717:    if (root) 
                    718:      {
                    719:        strcpy (temppath, root);
1.25      cvs       720:        TtaFreeMemory (root);
1.22      cvs       721:        /* Get the suffix */
                    722:        ExtractSuffix (temppath, suffix); 
                    723: 
                    724:        if( suffix[0] == EOS)
                    725:         /* no suffix */
                    726:         return (FALSE);
                    727: 
                    728:        /* Normalize the suffix */
                    729:        ConvertToLowerCase (suffix);
                    730: 
1.23      cvs       731:        if (!strcmp (suffix, "gz"))
1.22      cvs       732:         /* skip the compressed suffix */
                    733:         {
                    734:         ExtractSuffix (temppath, suffix);
                    735:         if(suffix[0] == EOS)
                    736:           /* no suffix */
                    737:           return (FALSE);
                    738:          /* Normalize the suffix */
                    739:          ConvertToLowerCase (suffix);
                    740:         }
                    741: 
                    742:        if ((strcmp (suffix, "gif")) && (strcmp (suffix, "xbm")) &&
                    743:           (strcmp (suffix, "xpm")) && (strcmp (suffix, "jpg")) &&
                    744:           (strcmp (suffix, "pdf")) && (strcmp (suffix, "png")) &&
                    745:           (strcmp (suffix, "tgz")) && (strcmp (suffix, "xpg")) &&
                    746:           (strcmp (suffix, "xpd")) && (strcmp (suffix, "ps")) &&
                    747:           (strcmp (suffix, "au"))  && (strcmp (suffix, "html")) &&
                    748:           (strcmp (suffix, "htm")) && (strcmp (suffix, "shtml")) &&
                    749:           (strcmp (suffix, "txt")) && (strcmp (suffix, "css")) &&
                    750:           (strcmp (suffix, "eps")))
                    751:         return (FALSE);
                    752:        else
                    753:         return (TRUE);
                    754:      }
                    755:    else
                    756:      return (FALSE);
                    757: }
                    758: 
                    759: 
                    760: /*----------------------------------------------------------------------
1.24      cvs       761:   ChopURL
                    762:   Gives back a URL no longer than MAX_PRINT_URL_LENGTH chars (outputURL). 
                    763:   If inputURL is  bigger than that size, outputURL receives
                    764:   MAX_PRINT_URL_LENGTH / 2 chars from the beginning of inputURL, "...", 
                    765:   and MAX_PRINT_URL_LENGTH / 2 chars from the end of inputURL.
                    766:   If inputURL is not longer than MAX_PRINT_URL_LENGTH chars, it gets
                    767:   copied into outputURL. 
                    768:   N.B.: outputURL must point to a memory block of MAX_PRINT_URL_LENGTH
                    769:   chars.
                    770:   ----------------------------------------------------------------------*/
                    771: #ifdef __STDC__
1.34      cvs       772: void ChopURL (char *outputURL, const char *inputURL)
1.24      cvs       773: #else
                    774: void ChopURL (outputURL, inputURL)
1.34      cvs       775: char       *outputURL;
                    776: const char *inputURL;
1.24      cvs       777: #endif
1.22      cvs       778: 
1.24      cvs       779: {
                    780:   int len;
1.9       cvs       781: 
1.24      cvs       782:   len = strlen (inputURL);
                    783:   if (len <= MAX_PRINT_URL_LENGTH) 
1.29      cvs       784:     strcpy (outputURL, inputURL);
1.24      cvs       785:   else
                    786:     /* make a truncated urlName on the status window */
                    787:     {
                    788:       strncpy (outputURL, inputURL, MAX_PRINT_URL_LENGTH / 2);
                    789:       outputURL [MAX_PRINT_URL_LENGTH / 2] = EOS;
                    790:       strcat (outputURL, "...");
                    791:       strcat (outputURL, &(inputURL[len - MAX_PRINT_URL_LENGTH / 2 ]));
                    792:     }
1.25      cvs       793: }
                    794: 
                    795: 
                    796: /*----------------------------------------------------------------------
                    797:    scan
                    798:        Scan a filename for its consituents
                    799:        -----------------------------------
                    800:   
                    801:    On entry,
                    802:        name    points to a document name which may be incomplete.
                    803:    On exit,
                    804:         absolute or relative may be nonzero (but not both).
                    805:        host, fragment and access may be nonzero if they were specified.
                    806:        Any which are nonzero point to zero terminated strings.
                    807:   ----------------------------------------------------------------------*/
                    808: #ifdef __STDC__
                    809: static void scan (char * name, HTURI * parts)
                    810: #else  /* __STDC__ */
                    811: static void scan (name, parts)
                    812: char                *name;
                    813: HTURI               *parts;
                    814: 
                    815: #endif /* __STDC__ */
                    816: {
1.28      cvs       817:   char * p;
                    818:   char * after_access = name;
1.33      cvs       819:   char       used_sep;
1.32      cvs       820: 
1.33      cvs       821:   if (name && strchr (name, URL_SEP))
                    822:     {
                    823:       used_sep = URL_SEP;
                    824:     }
                    825:   else
                    826:     {
                    827:       used_sep = DIR_SEP;
                    828:     }
1.32      cvs       829: 
1.28      cvs       830:   memset(parts, '\0', sizeof(HTURI));
                    831:   /* Look for fragment identifier */
                    832:   if ((p = strrchr(name, '#')) != NULL)
                    833:     {
                    834:       *p++ = '\0';
                    835:       parts->fragment = p;
1.25      cvs       836:     }
                    837:     
1.28      cvs       838:   for (p=name; *p; p++)
                    839:     {
1.33      cvs       840:       if (*p==used_sep || *p=='#' || *p=='?')
1.28      cvs       841:        break;
1.32      cvs       842:       if (*p==':')
1.28      cvs       843:        {
                    844:          *p = 0;
                    845:          parts->access = after_access; /* Scheme has been specified */
                    846: 
                    847:          /* The combination of gcc, the "-O" flag and the HP platform is
                    848:             unhealthy. The following three lines is a quick & dirty fix, but is
                    849:             not recommended. Rather, turn off "-O". */
                    850: 
                    851:          /*            after_access = p;*/
                    852:          /*            while (*after_access == 0)*/
                    853:          /*                after_access++;*/
                    854:          after_access = p+1;
                    855:          if (0==strcasecmp("URL", parts->access))
                    856:            /* Ignore IETF's URL: pre-prefix */
                    857:            parts->access = NULL;
                    858:          else
1.25      cvs       859:            break;
                    860:        }
                    861:     }
                    862:     
                    863:     p = after_access;
1.33      cvs       864:     if (*p==used_sep)
1.28      cvs       865:       {
1.33      cvs       866:        if (p[1]==used_sep)
1.28      cvs       867:          {
1.25      cvs       868:            parts->host = p+2;          /* host has been specified      */
1.28      cvs       869:            *p = 0;                     /* Terminate access             */
                    870:            /* look for end of host name if any */
1.33      cvs       871:            p = strchr(parts->host,used_sep);
1.28      cvs       872:            if (p)
                    873:              {
1.25      cvs       874:                *p=0;                   /* Terminate host */
                    875:                parts->absolute = p+1;          /* Root has been found */
1.28      cvs       876:              }
                    877:          }
                    878:        else
                    879:          /* Root found but no host */
                    880:          parts->absolute = p+1;
                    881:       }
                    882:     else
                    883:       {
1.25      cvs       884:         parts->relative = (*after_access) ? after_access : 0; /* zero for "" */
1.28      cvs       885:       }
1.25      cvs       886: }
                    887: 
                    888: 
                    889: /*----------------------------------------------------------------------
1.28      cvs       890:   AmayaParseUrl: parse a Name relative to another name
                    891: 
                    892:   This returns those parts of a name which are given (and requested)
                    893:   substituting bits from the related name where necessary.
1.25      cvs       894:   
1.28      cvs       895:   On entry,
1.25      cvs       896:        aName           A filename given
                    897:         relatedName     A name relative to which aName is to be parsed. Give
                    898:                         it an empty string if aName is absolute.
                    899:         wanted          A mask for the bits which are wanted.
                    900:   
1.28      cvs       901:   On exit,
1.25      cvs       902:        returns         A pointer to a malloc'd string which MUST BE FREED
                    903:   ----------------------------------------------------------------------*/
                    904: #ifdef __STDC__
1.34      cvs       905: char          *AmayaParseUrl (const char *aName, char *relatedName, int wanted)
1.25      cvs       906: #else  /* __STDC__ */
1.28      cvs       907: char          *AmayaParseUrl (aName, relatedName, wanted)
1.34      cvs       908: const char    *aName;
1.28      cvs       909: char          *relatedName;
                    910: int            wanted;
1.25      cvs       911: 
                    912: #endif /* __STDC__ */
                    913: {
1.29      cvs       914:   char      *return_value;
                    915:   char       result[MAX_LENGTH];
                    916:   char       name[MAX_LENGTH];
                    917:   char       rel[MAX_LENGTH];
                    918:   char      *p, *access;
                    919:   HTURI      given, related;
                    920:   int        len;
1.33      cvs       921:   char       used_sep;
                    922:   char      *used_str;
1.32      cvs       923: 
1.33      cvs       924:   if (strchr (aName, URL_SEP) || strchr (relatedName, URL_SEP) )
                    925:     {
                    926:       used_str = URL_STR;
                    927:       used_sep = URL_SEP;
                    928:     }
1.32      cvs       929:   else
1.33      cvs       930:     {
                    931:       used_str = DIR_STR;
                    932:       used_sep = DIR_SEP;
                    933:     }
1.32      cvs       934: 
1.29      cvs       935:   /* Make working copies of input strings to cut up: */
                    936:   return_value = NULL;
                    937:   result[0] = 0;               /* Clear string  */
                    938:   strcpy (name, aName);
                    939:   if (relatedName != NULL)  
                    940:     strcpy (rel, relatedName);
                    941:   else
                    942:     relatedName[0] = EOS;
                    943:   
                    944:   scan (name, &given);
                    945:   scan (rel,  &related); 
                    946:   access = given.access ? given.access : related.access;
                    947:   if (wanted & AMAYA_PARSE_ACCESS)
                    948:     if (access)
                    949:       {
                    950:        strcat (result, access);
                    951:        if(wanted & AMAYA_PARSE_PUNCTUATION)
1.32      cvs       952:                strcat (result, ":");
1.29      cvs       953:       }
                    954:   
                    955:   if (given.access && related.access)
                    956:     /* If different, inherit nothing. */
                    957:     if (strcmp (given.access, related.access) != 0)
                    958:       {
                    959:        related.host = 0;
                    960:        related.absolute = 0;
                    961:        related.relative = 0;
                    962:        related.fragment = 0;
                    963:       }
                    964:   
                    965:   if (wanted & AMAYA_PARSE_HOST)
                    966:     if(given.host || related.host)
                    967:       {
                    968:        if(wanted & AMAYA_PARSE_PUNCTUATION)
                    969:          strcat (result, "//");
                    970:        strcat (result, given.host ? given.host : related.host);
                    971:       }
                    972:   
                    973:   if (given.host && related.host)
                    974:     /* If different hosts, inherit no path. */
                    975:     if (strcmp(given.host, related.host) != 0)
                    976:       {
                    977:        related.absolute = 0;
                    978:        related.relative = 0;
                    979:        related.fragment = 0;
                    980:       }
                    981:   
                    982:   if (wanted & AMAYA_PARSE_PATH)
                    983:     {
                    984:       if (given.absolute)
                    985:        {
                    986:          /* All is given */
                    987:          if (wanted & AMAYA_PARSE_PUNCTUATION)
1.33      cvs       988:            strcat (result, used_str);
1.29      cvs       989:          strcat (result, given.absolute);
1.25      cvs       990:        }
1.29      cvs       991:       else if (related.absolute)
                    992:        {
                    993:          /* Adopt path not name */
1.33      cvs       994:          strcat (result, used_str);
1.29      cvs       995:          strcat (result, related.absolute);
                    996:          if (given.relative)
                    997:            {
                    998:              /* Search part? */
                    999:              p = strchr (result, '?');
                   1000:              if (!p)
                   1001:                p=result+strlen(result)-1;
1.33      cvs      1002:              for (; *p!=used_sep; p--);        /* last / */
1.29      cvs      1003:              /* Remove filename */
                   1004:              p[1]=0;
                   1005:              /* Add given one */
                   1006:              strcat (result, given.relative);
                   1007:              /*SimplifyUrl (&result);*/
1.25      cvs      1008:            }
                   1009:        }
1.29      cvs      1010:       else if (given.relative)
                   1011:        /* what we've got */
                   1012:        strcat (result, given.relative);
                   1013:       else if (related.relative)
                   1014:        strcat (result, related.relative);
                   1015:       else
                   1016:        /* No inheritance */
1.33      cvs      1017:        strcat (result, used_str);
1.25      cvs      1018:     }
1.29      cvs      1019:   
                   1020:   if (wanted & AMAYA_PARSE_ANCHOR)
                   1021:     if (given.fragment || related.fragment)
                   1022:       {
                   1023:        if (given.absolute && given.fragment)
                   1024:          {
                   1025:            /*Fixes for relURLs...*/
                   1026:            if (wanted & AMAYA_PARSE_PUNCTUATION)
                   1027:              strcat (result, "#");
                   1028:            strcat (result, given.fragment); 
                   1029:          }
                   1030:        else if (!(given.absolute) && !(given.fragment))
                   1031:          strcat (result, "");
                   1032:        else
                   1033:          {
                   1034:            if (wanted & AMAYA_PARSE_PUNCTUATION)
                   1035:              strcat (result, "#");
                   1036:            strcat (result, given.fragment ? given.fragment : related.fragment); 
                   1037:          }
                   1038:       }
                   1039:   len = strlen (result);
                   1040:   if ((return_value = (char *) TtaGetMemory (len + 1)) != NULL)
                   1041:     strcpy (return_value, result);
                   1042:   return (return_value);               /* exactly the right length */
1.25      cvs      1043: }
                   1044: 
                   1045: /*----------------------------------------------------------------------
                   1046:      HTCanon
                   1047:        Canonicalizes the URL in the following manner starting from the host
                   1048:        pointer:
                   1049:   
                   1050:        1) The host name is converted to lowercase
                   1051:        2) Chop off port if `:80' (http), `:70' (gopher), or `:21' (ftp)
                   1052:   
                   1053:        Return: OK      The position of the current path part of the URL
                   1054:                        which might be the old one or a new one.
                   1055:   
                   1056:   ----------------------------------------------------------------------*/
                   1057: #ifdef __STDC__
1.28      cvs      1058: static char *HTCanon (char ** filename, char * host)
1.25      cvs      1059: #else  /* __STDC__ */
1.28      cvs      1060: static char *HTCanon (filename, host)
                   1061: char       **filename;
                   1062: char        *host;
1.25      cvs      1063: #endif /* __STDC__ */
                   1064: {
                   1065:     char *newname = NULL;
                   1066:     char *port;
                   1067:     char *strptr;
                   1068:     char *path;
                   1069:     char *access = host-3;
1.33      cvs      1070:     char       used_sep;
1.32      cvs      1071: 
                   1072:   
1.33      cvs      1073:      if (*filename && strchr (*filename, URL_SEP))
                   1074:        {
                   1075:         used_sep = URL_SEP;
                   1076:        }
                   1077:      else
                   1078:        {
                   1079:         used_sep = DIR_SEP;
                   1080:        }
1.32      cvs      1081:   
1.33      cvs      1082:     while (access>*filename && *(access-1)!= used_sep)       /* Find access method */
1.25      cvs      1083:        access--;
1.33      cvs      1084:     if ((path = strchr(host, used_sep)) == NULL)                       /* Find path */
1.25      cvs      1085:        path = host + strlen(host);
                   1086:     if ((strptr = strchr(host, '@')) != NULL && strptr<path)      /* UserId */
                   1087:        host = strptr;
1.32      cvs      1088:     if ((port = strchr(host, ':')) != NULL && port>path)      /* Port number */
1.25      cvs      1089:        port = NULL;
                   1090: 
                   1091:     strptr = host;                                 /* Convert to lower-case */
1.33      cvs      1092:     while (strptr<path)
                   1093:       {
1.25      cvs      1094:        *strptr = tolower(*strptr);
                   1095:        strptr++;
1.33      cvs      1096:       }
1.25      cvs      1097:     
                   1098:     /* Does the URL contain a full domain name? This also works for a
                   1099:        numerical host name. The domain name is already made lower-case
                   1100:        and without a trailing dot. */
                   1101:     {
1.33      cvs      1102:       char *dot = port ? port : path;
                   1103:       if (dot > *filename && *--dot=='.')
                   1104:        {
                   1105:          char *orig=dot, *dest=dot+1;
                   1106:          while((*orig++ = *dest++));
                   1107:          if (port) port--;
                   1108:          path--;
1.25      cvs      1109:        }
                   1110:     }
                   1111:     /* Chop off port if `:', `:80' (http), `:70' (gopher), or `:21' (ftp) */
1.33      cvs      1112:     if (port)
                   1113:       {
                   1114:        if (!*(port+1) || *(port+1)==used_sep)
                   1115:          {
                   1116:            if (!newname)
                   1117:              {
1.25      cvs      1118:                char *orig=port, *dest=port+1;
                   1119:                while((*orig++ = *dest++));
1.33      cvs      1120:              }
                   1121:          }
                   1122:        else if ((!strncmp(access, "http", 4) &&
                   1123:                  (*(port+1)=='8'&&*(port+2)=='0'&&(*(port+3)==used_sep||!*(port+3)))) ||
                   1124:                 (!strncmp(access, "gopher", 6) &&
                   1125:                  (*(port+1)=='7'&&*(port+2)=='0'&&(*(port+3)==used_sep||!*(port+3)))) ||
                   1126:                 (!strncmp(access, "ftp", 3) &&
                   1127:                  (*(port+1)=='2'&&*(port+2)=='1'&&(*(port+3)==used_sep||!*(port+3))))) {
                   1128:          if (!newname)
                   1129:            {
                   1130:              char *orig=port, *dest=port+3;
                   1131:              while((*orig++ = *dest++));
                   1132:              /* Update path position, Henry Minsky */
                   1133:              path -= 3;
1.25      cvs      1134:            }
1.33      cvs      1135:        }
                   1136:        else if (newname)
                   1137:          strncat(newname, port, (int) (path-port));
                   1138:       }
1.25      cvs      1139: 
1.33      cvs      1140:     if (newname)
                   1141:       {
1.25      cvs      1142:        char *newpath = newname+strlen(newname);
                   1143:        strcat(newname, path);
                   1144:        path = newpath;
1.28      cvs      1145:        /* Free old copy */
                   1146:        TtaFreeMemory(*filename);
1.25      cvs      1147:        *filename = newname;
1.33      cvs      1148:       }
1.25      cvs      1149:     return path;
                   1150: }
                   1151: 
                   1152: 
                   1153: /*----------------------------------------------------------------------
1.29      cvs      1154:   SimplifyUrl: simplify a URI
1.32      cvs      1155:   A URI is allowed to contain the sequence xxx/../ which may be
                   1156:   replaced by "" , and the sequence "/./" which may be replaced by DIR_STR.
1.28      cvs      1157:   Simplification helps us recognize duplicate URIs. 
1.25      cvs      1158:   
1.28      cvs      1159:   Thus,        /etc/junk/../fred       becomes /etc/fred
                   1160:                 /etc/junk/./fred       becomes /etc/junk/fred
1.25      cvs      1161:   
1.28      cvs      1162:   but we should NOT change
                   1163:                 http://fred.xxx.edu/../..
1.25      cvs      1164:   
                   1165:        or      ../../albert.html
                   1166:   
1.28      cvs      1167:   In order to avoid empty URLs the following URLs become:
1.25      cvs      1168:   
                   1169:                /fred/..                becomes /fred/..
                   1170:                /fred/././..            becomes /fred/..
                   1171:                /fred/.././junk/.././   becomes /fred/..
                   1172:   
1.28      cvs      1173:   If more than one set of `://' is found (several proxies in cascade) then
                   1174:   only the part after the last `://' is simplified.
1.25      cvs      1175:   
1.28      cvs      1176:   Returns: A string which might be the old one or a new one.
1.25      cvs      1177:   ----------------------------------------------------------------------*/
                   1178: #ifdef __STDC__
1.29      cvs      1179: void         SimplifyUrl (char ** url)
1.25      cvs      1180: #else  /* __STDC__ */
1.29      cvs      1181: void         SimplifyUrl (url)
1.28      cvs      1182: char        **url;
1.25      cvs      1183: #endif /* __STDC__ */
                   1184: {
1.28      cvs      1185:   char *path, *p;
                   1186:   char *newptr, *access;
                   1187:   char *orig, *dest, *end;
                   1188: 
1.33      cvs      1189:   char       used_sep;
1.32      cvs      1190: 
                   1191: 
1.28      cvs      1192:   if (!url || !*url)
                   1193:     return;
                   1194: 
1.33      cvs      1195:   if (strchr (*url, URL_SEP))
                   1196:     {
                   1197:       used_sep = URL_SEP;
                   1198:     }
1.32      cvs      1199:   else
1.33      cvs      1200:     {
                   1201:       used_sep = DIR_SEP;
                   1202:     }
1.32      cvs      1203: 
1.28      cvs      1204:   /* Find any scheme name */
                   1205:   if ((path = strstr(*url, "://")) != NULL)
1.33      cvs      1206:     {
                   1207:       /* Find host name */
1.28      cvs      1208:       access = *url;
                   1209:       while (access<path && (*access=tolower(*access)))
                   1210:        access++;
                   1211:       path += 3;
                   1212:       while ((newptr = strstr(path, "://")) != NULL)
                   1213:         /* For proxies */
                   1214:        path = newptr+3;
                   1215:       /* We have a host name */
                   1216:       path = HTCanon(url, path);
1.25      cvs      1217:     }
1.28      cvs      1218:   else if ((path = strstr(*url, ":/")) != NULL)
                   1219:     path += 2;
                   1220:   else
                   1221:     path = *url;
1.25      cvs      1222: 
1.33      cvs      1223:   if (*path == used_sep && *(path+1)==used_sep)
1.28      cvs      1224:     /* Some URLs start //<foo> */
                   1225:     path += 1;
                   1226:   else if (!strncmp(path, "news:", 5))
                   1227:     {
                   1228:       newptr = strchr(path+5, '@');
                   1229:       if (!newptr)
                   1230:        newptr = path + 5;
                   1231:       while (*newptr)
                   1232:        {
                   1233:          /* Make group or host lower case */
                   1234:          *newptr = tolower (*newptr);
                   1235:          newptr++;
1.25      cvs      1236:        }
1.28      cvs      1237:       /* Doesn't need to do any more */
                   1238:       return;
1.25      cvs      1239:     }
1.28      cvs      1240: 
                   1241:   if ((p = path))
                   1242:     {
                   1243:       if (!((end = strchr (path, ';')) || (end = strchr (path, '?')) ||
                   1244:            (end = strchr (path, '#'))))
                   1245:        end = path + strlen (path);
                   1246:       
                   1247:       /* Parse string second time to simplify */
                   1248:       p = path;
                   1249:       while (p < end)
                   1250:        {
1.33      cvs      1251:          if (*p==used_sep)
1.28      cvs      1252:            {
1.33      cvs      1253:              if (p > *url && *(p+1) == '.' && (*(p+2) == used_sep || !*(p+2)))
1.28      cvs      1254:                {
                   1255:                  orig = p + 1;
1.33      cvs      1256:                  dest = (*(p+2)!=used_sep) ? p+2 : p+3;
1.28      cvs      1257:                  while ((*orig++ = *dest++)); /* Remove a slash and a dot */
                   1258:                  end = orig - 1;
                   1259:                }
1.33      cvs      1260:              else if (*(p+1)=='.' && *(p+2)=='.' && (*(p+3)==used_sep || !*(p+3)))
1.28      cvs      1261:                {
                   1262:                  newptr = p;
1.33      cvs      1263:                  while (newptr>path && *--newptr!=used_sep); /* prev slash */
1.28      cvs      1264:                  if (strncmp(newptr, "/../", 4))
                   1265:                    {
                   1266:                      orig = newptr + 1;
1.33      cvs      1267:                      dest = (*(p+3)!=used_sep) ? p+3 : p+4;
1.28      cvs      1268:                      while ((*orig++ = *dest++)); /* Remove /xxx/.. */
                   1269:                      end = orig-1;
                   1270:                      /* Start again with prev slash */
                   1271:                      p = newptr;
1.25      cvs      1272:                    }
1.28      cvs      1273:                  else
1.25      cvs      1274:                    p++;
1.28      cvs      1275:                }
1.33      cvs      1276:              else if (*(p+1) == used_sep)
1.28      cvs      1277:                {
1.33      cvs      1278:                  while (*(p+1) == used_sep)
1.28      cvs      1279:                    {
                   1280:                      orig = p;
                   1281:                      dest = p + 1;
                   1282:                      while ((*orig++ = *dest++));  /* Remove multiple /'s */
                   1283:                      end = orig-1;
                   1284:                    }
                   1285:                }
                   1286:              else
1.25      cvs      1287:                p++;
1.28      cvs      1288:            }
                   1289:          else
                   1290:            p++;
1.25      cvs      1291:        }
                   1292:     }
1.28      cvs      1293:   return;
                   1294: }
                   1295: 
                   1296: 
                   1297: /*----------------------------------------------------------------------
                   1298:    NormalizeFile normalizes  local names.                             
                   1299:    Return TRUE if target and src differ.                           
                   1300:   ----------------------------------------------------------------------*/
                   1301: #ifdef __STDC__
                   1302: boolean             NormalizeFile (char *src, char *target)
                   1303: #else
                   1304: boolean             NormalizeFile (src, target)
                   1305: char               *src;
                   1306: char               *target;
                   1307: 
                   1308: #endif
                   1309: {
                   1310:    char               *s;
                   1311:    boolean             change;
                   1312: 
                   1313:    change = FALSE;
                   1314:    if (src[0] == '~')
                   1315:      {
                   1316:        /* replace ~ */
                   1317:        s = (char *) TtaGetEnvString ("HOME");
                   1318:        strcpy (target, s);
                   1319:        strcat (target, &src[1]);
                   1320:        change = TRUE;
                   1321:      }
                   1322:    else if (strncmp (src, "file:", 5) == 0)
                   1323:      {
                   1324:        /* remove the prefix file: */
                   1325:        if (src[5] == EOS)
                   1326:           strcpy (target, DIR_STR);
                   1327:        else if (src[0] == '~')
                   1328:          {
                   1329:            /* replace ~ */
                   1330:            s = (char *) TtaGetEnvString ("HOME");
                   1331:            strcpy (target, s);
                   1332:            strcat (target, &src[5]);
                   1333:          }
                   1334:        else
                   1335:           strcpy (target, &src[5]);
                   1336:        change = TRUE;
                   1337:      }
                   1338:    else
                   1339:       strcpy (target, src);
                   1340: 
                   1341:    /* remove /../ and /./ */
1.29      cvs      1342:    SimplifyUrl (&target);
1.28      cvs      1343:    return (change);
1.25      cvs      1344: }
                   1345: 
1.28      cvs      1346: 
1.25      cvs      1347: /*----------------------------------------------------------------------
1.31      cvs      1348:   MakeRelativeURL: make relative name
1.25      cvs      1349:   
1.28      cvs      1350:   This function creates and returns a string which gives an expression of
                   1351:   one address as related to another. Where there is no relation, an absolute
                   1352:   address is retured.
1.25      cvs      1353:   
1.28      cvs      1354:   On entry,
1.25      cvs      1355:        Both names must be absolute, fully qualified names of nodes
                   1356:        (no fragment bits)
                   1357:   
1.28      cvs      1358:   On exit,
1.25      cvs      1359:        The return result points to a newly allocated name which, if
                   1360:        parsed by AmayaParseUrl relative to relatedName, will yield aName.
                   1361:        The caller is responsible for freeing the resulting name later.
                   1362:   ----------------------------------------------------------------------*/
                   1363: #ifdef __STDC__
1.31      cvs      1364: char            *MakeRelativeURL (char *aName, char *relatedName)
1.25      cvs      1365: #else  /* __STDC__ */
1.31      cvs      1366: char            *MakeRelativeURL (aName, relatedName)
1.28      cvs      1367: char            *aName;
                   1368: char            *relatedName;
1.25      cvs      1369: #endif  /* __STDC__ */
                   1370: {
1.39    ! cvs      1371:   char          *return_value;
        !          1372:   char           result[MAX_LENGTH];
1.29      cvs      1373:   char          *p;
1.34      cvs      1374:   char          *q;
1.29      cvs      1375:   char          *after_access;
                   1376:   char          *last_slash = NULL;
                   1377:   int            slashes, levels, len;
                   1378: 
                   1379:   if (aName == NULL || relatedName == NULL)
                   1380:     return (NULL);
                   1381: 
                   1382:   slashes = 0;
                   1383:   after_access = NULL;
                   1384:   p = aName;
                   1385:   q = relatedName;
                   1386:   for (; *p && (*p == *q); p++, q++)
1.27      cvs      1387:     {
                   1388:       /* Find extent of match */
1.32      cvs      1389:       if (*p == ':')
1.29      cvs      1390:        after_access = p + 1;
1.28      cvs      1391:       if (*p == DIR_SEP)
1.27      cvs      1392:        {
1.29      cvs      1393:          /* memorize the last slash position and count them */
1.27      cvs      1394:          last_slash = p;
                   1395:          slashes++;
1.25      cvs      1396:        }
                   1397:     }
                   1398:     
1.31      cvs      1399:   /* q, p point to the first non-matching character or zero */
                   1400:   if (*q == EOS)
                   1401:     {
                   1402:       /* New name is a subset of the related name */
                   1403:       /* exactly the right length */
                   1404:       len = strlen (p);
                   1405:       if ((return_value = (char *) TtaGetMemory (len + 1)) != NULL)
                   1406:        strcpy (return_value, p);
                   1407:     }
                   1408:   else if ((slashes < 2 && after_access == NULL)
                   1409:       || (slashes < 3 && after_access != NULL))
                   1410:     {
                   1411:       /* Two names whitout common path */
                   1412:       /* exactly the right length */
                   1413:       len = strlen (aName);
                   1414:       if ((return_value = (char *) TtaGetMemory (len + 1)) != NULL)
                   1415:        strcpy (return_value, aName);
                   1416:     }
                   1417:   else
                   1418:     {
                   1419:       /* Some path in common */
                   1420:       if (slashes == 3 && strncmp (aName, "http:", 5) == 0)
                   1421:        /* just the same server */
                   1422:        strcpy (result, last_slash);
                   1423:       else
                   1424:        {
                   1425:          levels= 0; 
                   1426:          for (; *q && (*q != '#'); q++)
                   1427:            if (*q == DIR_SEP)
                   1428:              levels++;
                   1429:          
                   1430:          result[0] = 0;
                   1431:          for (;levels; levels--)
                   1432:            strcat (result, "../");
                   1433:          strcat (result, last_slash+1);
                   1434:        } 
                   1435:       
                   1436:       /* exactly the right length */
                   1437:       len = strlen (result);
                   1438:       if ((return_value = (char *) TtaGetMemory (len + 1)) != NULL)
                   1439:        strcpy (return_value, result);
1.25      cvs      1440:     }
1.29      cvs      1441:   return (return_value);
1.24      cvs      1442: }
1.35      cvs      1443: 
                   1444: 

Webmaster