Annotation of libwww/Library/src/HTFWrite.c, revision 2.9

2.1       frystyk     1: /*                                                                 HTFWrite.c
                      2: **     FILE WRITER
                      3: **
2.6       frystyk     4: **     (c) COPYRIGHT MIT 1995.
2.1       frystyk     5: **     Please first read the full copyright statement in the file COPYRIGH.
                      6: **
                      7: **     This version of the stream object just writes to a C file.
                      8: **     The file is assumed open and left open.
                      9: **
                     10: **     Bugs:
                     11: **             strings written must be less than buffer size.
                     12: **
                     13: **      History:
                     14: **         HFN: wrote it
                     15: **         HWL: converted the caching scheme to be hierachical by taking
                     16: **              AL code from Deamon
                     17: **
                     18: */
                     19: 
                     20: /* Library include files */
                     21: #include "tcp.h"
                     22: #include "HTUtils.h"
                     23: #include "HTString.h"
                     24: #include "HTFormat.h"
                     25: #include "HTAlert.h"
2.4       frystyk    26: #include "HTBind.h"
2.1       frystyk    27: #include "HTList.h"
2.3       frystyk    28: #include "HTParse.h"
                     29: #include "HTFWrite.h"                                   /* Implemented here */
2.1       frystyk    30: 
2.4       frystyk    31: #define HASH_SIZE 1001         /* Tunable */
                     32: 
2.1       frystyk    33: #define CACHE_LIMIT 100                /* files */
                     34: 
2.3       frystyk    35: #define CACHE_INFO     ".cache_info"
                     36: #define INDEX_FILE     ".cache_dirindex"
                     37: #define WELCOME_FILE   ".cache_welcome"
                     38: #define TMP_SUFFIX     ".cache_tmp"
                     39: #define LOCK_SUFFIX    ".cache_lock"
2.1       frystyk    40: 
2.3       frystyk    41: PUBLIC int  HTCacheLimit = CACHE_LIMIT;
2.1       frystyk    42: 
2.3       frystyk    43: struct _HTStream {
                     44:        CONST HTStreamClass *   isa;
                     45:        
                     46:        FILE *                  fp;
                     47:        BOOL                    leave_open;     /* Close file? HFN 08/02-94 */
                     48:        char *                  end_command;
                     49:        BOOL                    remove_on_close;
                     50:        BOOL                    announce;
                     51:        char *                  filename;
                     52:        HTRequest *             request;        /* saved for callback */
                     53:        BOOL (*callback) PARAMS((struct _HTRequest * req, void * filename));
                     54:        HTCacheItem *           cache;
                     55: };
2.1       frystyk    56: 
2.3       frystyk    57: PRIVATE HTStream       HTBlackHoleInstance;                  /* Made static */
2.1       frystyk    58: 
2.3       frystyk    59: PRIVATE BOOL           HTCacheEnable = NO;
                     60: PRIVATE char *         HTCacheRoot = NULL;         /* Destination for cache */
                     61: PRIVATE HTList *       HTCache = NULL;           /* List of cached elements */
2.1       frystyk    62: 
2.3       frystyk    63: PRIVATE char *         HTTmpRoot = NULL;              /* Dest for tmp files */
2.1       frystyk    64: 
2.3       frystyk    65: /* ------------------------------------------------------------------------- */
                     66: /*                          BASIC STREAM CLASSES                            */
                     67: /* ------------------------------------------------------------------------- */
2.1       frystyk    68: 
2.3       frystyk    69: /*
2.1       frystyk    70: **
2.3       frystyk    71: **             B L A C K    H O L E    C L A S S
2.1       frystyk    72: **
2.3       frystyk    73: **     There is only one black hole instance shared by anyone
                     74: **     who wants a black hole.  These black holes don't radiate,
                     75: **     they just absorb data.
                     76: */
                     77: PRIVATE int HTBlackHole_put_character ARGS2(HTStream *, me, char, c)
                     78: {
                     79:     return HT_OK;
                     80: }
                     81: 
                     82: PRIVATE int HTBlackHole_put_string ARGS2(HTStream *, me, CONST char*, s)
                     83: {
                     84:     return HT_OK;
                     85: }
                     86: 
                     87: PRIVATE int HTBlackHole_write ARGS3(HTStream *, me, CONST char*, s, int, l)
                     88: {
                     89:     return HT_OK;
                     90: }
                     91: 
                     92: PRIVATE int HTBlackHole_flush ARGS1(HTStream *, me)
                     93: {
                     94:     return HT_OK;
                     95: }
                     96: 
                     97: PRIVATE int HTBlackHole_free ARGS1(HTStream *, me)
                     98: {
                     99:     return HT_OK;
                    100: }
                    101: 
                    102: PRIVATE int HTBlackHole_abort ARGS2(HTStream *, me, HTError, e)
                    103: {
                    104:     return HT_ERROR;
                    105: }
                    106: 
                    107: 
                    108: /*     Black Hole stream
                    109: **     -----------------
                    110: */
                    111: PRIVATE CONST HTStreamClass HTBlackHoleClass =
                    112: {              
                    113:     "BlackHole",
                    114:     HTBlackHole_flush,
                    115:     HTBlackHole_free,
                    116:     HTBlackHole_abort,
                    117:     HTBlackHole_put_character,
                    118:     HTBlackHole_put_string,
                    119:     HTBlackHole_write
                    120: }; 
                    121: 
                    122: PUBLIC HTStream * HTBlackHole NOARGS
                    123: {
                    124:     if (TRACE)
                    125:        fprintf(TDEST, "BlackHole... Created\n");
                    126:     HTBlackHoleInstance.isa = &HTBlackHoleClass;       /* The rest is random */
                    127:     return &HTBlackHoleInstance;
                    128: }
                    129: 
                    130: 
                    131: /*     HTThroughLine
                    132: **     -------------
2.1       frystyk   133: **
2.3       frystyk   134: ** This function is a dummy function that returns the same output stream
                    135: ** as given as a parameter. Henrik 01/03-94
2.1       frystyk   136: */
2.3       frystyk   137: PUBLIC HTStream* HTThroughLine ARGS5(
                    138:        HTRequest *,            request,
                    139:        void *,                 param,
                    140:        HTFormat,               input_format,
                    141:        HTFormat,               output_format,
                    142:        HTStream *,             output_stream)              /* Only one used */
                    143: {
                    144:     return output_stream;
                    145: }
2.1       frystyk   146: 
2.3       frystyk   147: /* ------------------------------------------------------------------------- */
                    148: /*                          SOCKET WRITER STREAM                            */
                    149: /* ------------------------------------------------------------------------- */
                    150: 
                    151: PRIVATE int HTFWriter_put_character ARGS2(HTStream *, me, char, c)
                    152: {
                    153:     return (fputc(c, me->fp) == EOF) ? HT_ERROR : HT_OK;
                    154: }
                    155: 
                    156: PRIVATE int HTFWriter_put_string ARGS2(HTStream *, me, CONST char*, s)
                    157: {
                    158:     if (*s)                                         /* For vms :-( 10/04-94 */
                    159:        return (fputs(s, me->fp) == EOF) ? HT_ERROR : HT_OK;
                    160:     return HT_OK;
                    161: }
                    162: 
2.7       frystyk   163: PRIVATE int HTFWriter_flush ARGS1(HTStream *, me)
2.3       frystyk   164: {
2.7       frystyk   165:     return (fflush(me->fp) == EOF) ? HT_ERROR : HT_OK;
2.3       frystyk   166: }
                    167: 
2.7       frystyk   168: 
                    169: PRIVATE int HTFWriter_write ARGS3(HTStream *, me, CONST char*, s, int, l)
2.3       frystyk   170: {
2.7       frystyk   171:     int status ;
                    172:     status = (fwrite(s, 1, l, me->fp) != l) ? HT_ERROR : HT_OK ;
                    173:     if (l > 1 && status == HT_OK)
                    174:        (void)HTFWriter_flush( me) ;
                    175:     return status ;
                    176: 
                    177: /*    return (fwrite(s, 1, l, me->fp) != l) ? HT_ERROR : HT_OK; */
                    178:     
2.3       frystyk   179: }
2.7       frystyk   180: 
2.3       frystyk   181: 
                    182: PRIVATE int HTFWriter_free ARGS1(HTStream *, me)
                    183: {
                    184:     if (me->cache) {
                    185:         time_t finish_time;
                    186:        time(&finish_time);
                    187:        me->cache->load_delay = finish_time - me->cache->load_time;
                    188:        /* Actually, ought to use draft ANSI-C difftime() */
                    189:        /* But that I bet is more portable in real life  (@@?) */
                    190:     }
                    191: 
                    192:     if (me->leave_open != YES) fclose(me->fp);
                    193: 
                    194:     if (me->end_command) {             /* Temp file */
                    195:        system(me->end_command);        /* @@ Beware of security hole */
                    196:        free (me->end_command);
                    197:        if (me->remove_on_close) {
2.9     ! frystyk   198:            REMOVE(me->filename);
2.3       frystyk   199:        }
                    200:     }
                    201:     if (me->callback) {
                    202:         (*me->callback)(me->request, me->filename);
                    203:     }
                    204:     if (me->filename) free(me->filename);
                    205:     free(me);
                    206:     return HT_OK;
                    207: }
                    208: 
                    209: PRIVATE int HTFWriter_abort ARGS2(HTStream *, me, HTError, e)
                    210: {
                    211:     if (me->leave_open != YES) fclose(me->fp);
                    212:     if (me->end_command) {             /* Temp file */
                    213:        if (TRACE)
                    214:            fprintf(TDEST,"FileWriter.. Aborting: file %s not executed.\n",
                    215:                    me->filename ? me->filename : "???" );
                    216:        free (me->end_command);
                    217:        if (me->remove_on_close) {
2.9     ! frystyk   218:            REMOVE(me->filename);
2.3       frystyk   219:        }
                    220:     }
                    221: 
                    222:     if (me->filename) free(me->filename);
                    223:     free(me);
                    224:     return HT_ERROR;
                    225: }
                    226: 
                    227: PRIVATE CONST HTStreamClass HTFWriter = /* As opposed to print etc */
                    228: {              
                    229:     "FileWriter",
                    230:     HTFWriter_flush,
                    231:     HTFWriter_free,
                    232:     HTFWriter_abort,
                    233:     HTFWriter_put_character,
                    234:     HTFWriter_put_string,
                    235:     HTFWriter_write
                    236: };
                    237: 
                    238: PUBLIC HTStream* HTFWriter_new ARGS2(FILE *, fp, BOOL, leave_open)
                    239: {
                    240:     HTStream* me;
                    241:     
                    242:     if (!fp) {
                    243:        if (TRACE)
                    244:            fprintf(TDEST, "FileWriter.. Bad file descriptor\n");
                    245:        return NULL;
                    246:     }
                    247:     me = (HTStream*)calloc(sizeof(*me),1);
                    248:     if (me == NULL) outofmem(__FILE__, "HTFWriter_new");
                    249:     me->isa = &HTFWriter;       
                    250: 
                    251:     me->fp = fp;
                    252:     me->leave_open = leave_open;               /* HENRIK 08/02-94 */
                    253:     me->end_command = NULL;
                    254:     me->remove_on_close = NO;
                    255:     me->announce = NO;
                    256:     me->callback = NULL;
                    257:     return me;
                    258: }
                    259: 
                    260: /* ------------------------------------------------------------------------- */
                    261: /*                              CACHE MANAGER                               */
                    262: /* ------------------------------------------------------------------------- */
2.1       frystyk   263: 
                    264: /*
                    265: **     Check that the name we're about to generate doesn't
                    266: **     clash with anything used by the caching system.
                    267: */
                    268: PRIVATE BOOL reserved_name ARGS1(char *, url)
                    269: {
                    270:     char * name = strrchr(url, '/');
                    271:     char * suff = NULL;
                    272: 
                    273:     if (name) name++;
                    274:     else name = url;
                    275: 
                    276:     if (!strcmp(name, CACHE_INFO) ||
                    277:        !strcmp(name, INDEX_FILE) ||
                    278:        !strcmp(name, WELCOME_FILE))
                    279:        return YES;
                    280: 
                    281:     suff = strrchr(name, TMP_SUFFIX[0]);
                    282:     if (suff && !strcmp(suff, TMP_SUFFIX))
                    283:        return YES;
                    284: 
                    285:     suff = strrchr(name, LOCK_SUFFIX[0]);
                    286:     if (suff && !strcmp(suff, LOCK_SUFFIX))
                    287:        return YES;
                    288: 
                    289:     return NO;
                    290: }
                    291: 
                    292: 
                    293: /*
                    294: **     Map url to cache file name.
                    295: */
2.4       frystyk   296: PRIVATE char * cache_file_name ARGS1(char *, url)
2.1       frystyk   297: {
                    298:     char * access = NULL;
                    299:     char * host = NULL;
                    300:     char * path = NULL;
                    301:     char * cfn = NULL;
                    302:     BOOL welcome = NO;
                    303:     BOOL res = NO;
                    304: 
                    305:     if (!url ||  strchr(url, '?')  ||  (res = reserved_name(url))  ||
                    306:        !(access = HTParse(url, "", PARSE_ACCESS)) ||
                    307:        (0 != strcmp(access, "http") &&
                    308:         0 != strcmp(access, "ftp")  &&
                    309:         0 != strcmp(access, "gopher"))) {
                    310: 
                    311:        if (access) free(access);
                    312: 
2.3       frystyk   313:        if (res && CACHE_TRACE)
2.1       frystyk   314:            fprintf(TDEST,
                    315:                    "Cache....... Clash with reserved name (\"%s\")\n",url);
                    316: 
                    317:        return NULL;
                    318:     }
                    319: 
                    320:     host = HTParse(url, "", PARSE_HOST);
                    321:     path = HTParse(url, "", PARSE_PATH | PARSE_PUNCTUATION);
                    322:     if (path && path[strlen(path)-1] == '/')
                    323:        welcome = YES;
                    324: 
2.4       frystyk   325:     cfn = (char*)malloc(strlen(HTCacheRoot) +
2.1       frystyk   326:                        strlen(access) +
                    327:                        (host ? strlen(host) : 0) +
                    328:                        (path ? strlen(path) : 0) +
                    329:                        (welcome ? strlen(WELCOME_FILE) : 0) + 3);
                    330:     if (!cfn) outofmem(__FILE__, "cache_file_name");
2.3       frystyk   331: 
                    332:     /* Removed extra slash - HF May2,95 */
2.4       frystyk   333:     sprintf(cfn, "%s%s/%s%s%s", HTCacheRoot, access, host, path,
2.1       frystyk   334:            (welcome ? WELCOME_FILE : ""));
                    335: 
                    336:     FREE(access); FREE(host); FREE(path);
                    337: 
                    338:     /*
                    339:     ** This checks that the last component is not too long.
                    340:     ** It could check all the components, but the last one
                    341:     ** is most important because it could later blow up the
                    342:     ** whole gc when reading cache info files.
                    343:     ** Operating system handles other cases.
                    344:     ** 64 = 42 + 22  and  22 = 42 - 20  :-)
                    345:     ** In other words I just picked some number, it doesn't
                    346:     ** really matter that much.
                    347:     */
                    348:     {
                    349:        char * last = strrchr(cfn, '/');
                    350:        if (!last) last = cfn;
                    351:        if ((int)strlen(last) > 64) {
2.3       frystyk   352:            if (CACHE_TRACE)
2.1       frystyk   353:                fprintf(TDEST, "Too long.... cache file name \"%s\"\n", cfn);
                    354:            free(cfn);
                    355:            cfn = NULL;
                    356:        }
                    357:     }
                    358:     return cfn;
                    359: }
                    360: 
                    361: 
                    362: /*
                    363: **     Create directory path for cache file
                    364: **
                    365: ** On exit:
                    366: **     return YES
                    367: **             if directories created -- after that caller
                    368: **             can rely on fopen(cfn,"w") succeeding.
                    369: **
                    370: */
2.4       frystyk   371: PRIVATE BOOL create_cache_place ARGS1(char *, cfn)
2.1       frystyk   372: {
                    373:     struct stat stat_info;
                    374:     char * cur = NULL;
                    375:     BOOL create = NO;
                    376: 
2.4       frystyk   377:     if (!cfn  ||  (int)strlen(cfn) <= (int)strlen(HTCacheRoot) + 1)
2.1       frystyk   378:        return NO;
                    379: 
2.4       frystyk   380:     cur = cfn + strlen(HTCacheRoot) + 1;
2.1       frystyk   381: 
                    382:     while ((cur = strchr(cur, '/'))) {
                    383:        *cur = 0;
                    384:        if (create || HTStat(cfn, &stat_info) == -1) {
                    385:            create = YES;       /* To avoid doing stat()s in vain */
2.3       frystyk   386:            if (CACHE_TRACE)
2.1       frystyk   387:                fprintf(TDEST,"Cache....... creating cache dir \"%s\"\n",cfn);
2.3       frystyk   388:            if (MKDIR(cfn, 0777) < 0) {
                    389:                if (CACHE_TRACE)
                    390:                    fprintf(TDEST,"Cache....... can't create dir `%s\'\n",cfn);
2.1       frystyk   391:                return NO;
                    392:            }
2.3       frystyk   393:        } else {
2.1       frystyk   394:            if (S_ISREG(stat_info.st_mode)) {
                    395:                int len = strlen(cfn);
                    396:                char * tmp1 = (char*)malloc(len + strlen(TMP_SUFFIX) + 1);
                    397:                char * tmp2 = (char*)malloc(len + strlen(INDEX_FILE) + 2);
                    398:                /* time_t t1,t2,t3,t4,t5; */
                    399: 
                    400: 
                    401:                sprintf(tmp1, "%s%s", cfn, TMP_SUFFIX);
                    402:                sprintf(tmp2, "%s/%s", cfn, INDEX_FILE);
                    403: 
2.3       frystyk   404:                if (CACHE_TRACE) {
2.1       frystyk   405:                    fprintf(TDEST,"Cache....... moving \"%s\" to \"%s\"\n",
                    406:                            cfn,tmp1);
                    407:                    fprintf(TDEST,"and......... creating dir \"%s\"\n",
                    408:                            cfn);
                    409:                    fprintf(TDEST,"and......... moving \"%s\" to \"%s\"\n",
                    410:                            tmp1,tmp2);
                    411:                }
                    412:                rename(cfn,tmp1);
2.3       frystyk   413:                (void) MKDIR(cfn, 0777);
2.1       frystyk   414:                rename(tmp1,tmp2);
                    415: 
                    416: /*             if (HTCacheInfo_for(cfn,&t1,&t2,&t3,&t4,&t5)) {
2.3       frystyk   417:                    if (CACHE_TRACE)
2.1       frystyk   418:                       fprintf(TDEST,"Adding...... info entry for %s\n",tmp2);
                    419:                    if (!HTCacheInfo_writeEntryFor(tmp2,t1,t2,t3,t4,t5))
                    420:                        HTLog_error2("Can't write cache info entry for",tmp2);
                    421:                }
                    422: */
                    423:                free(tmp1);
                    424:                free(tmp2);
                    425:            }
                    426:            else {
2.3       frystyk   427:                if (CACHE_TRACE)
2.1       frystyk   428:                    fprintf(TDEST,"Cache....... dir \"%s\" already exists\n",
                    429:                            cfn);
                    430:            }
                    431:        }
                    432:        *cur = '/';
                    433:        cur++;
                    434:     }
                    435:     return YES;
                    436: }
                    437: 
                    438: 
2.4       frystyk   439: /*     Create a cache path
                    440: **     -------------------
                    441: **     Find a full path name for the cache file and create the path if it
                    442: **     does not already exist. Returns name or NULL
                    443: **     HWL 22/9/94
                    444: **     HWL added support for hierachical structure
                    445: */
                    446: PRIVATE char *HTCache_getName ARGS1(char *, url)
                    447: {
                    448:      char *filename = cache_file_name(url);
                    449:      if (!filename)
                    450:         return NULL;
                    451:      if (create_cache_place(filename))
                    452:         return(filename);
                    453:      return NULL;
2.1       frystyk   454: }
                    455: 
                    456: 
2.3       frystyk   457: PRIVATE void HTCache_remove ARGS2(HTList *, list, HTCacheItem *, item)
                    458: {
                    459:     if (CACHE_TRACE)
                    460:        fprintf(TDEST, "Cache: Removing %s\n", item->filename);
                    461:     HTList_removeObject(list, item);
                    462:     HTList_removeObject(item->anchor->cacheItems, item);
2.9     ! frystyk   463:     REMOVE(item->filename);
2.3       frystyk   464: 
                    465:     /* HWL 22/9/94: since we added a hierachical file structure, we should also clean up */
                    466:     {
                    467:        char * p;
2.1       frystyk   468: 
2.3       frystyk   469:        while ((p = strrchr(item->filename,'/')) && (p != NULL)){
                    470:            item->filename[p - item->filename] = 0; /* this will be freed in a sec */
                    471:            if (strcmp(item->filename, HTCacheRoot) != 0) {
                    472:                if (CACHE_TRACE) 
                    473:                    fprintf(TDEST, "rmdir %s\n", item->filename);
2.9     ! frystyk   474:                RMDIR(item->filename);         /* this will luckily fail if directory is not empty */
2.3       frystyk   475:            }
                    476:        }
                    477:     }
                    478: 
                    479:     free(item->filename);
                    480:     free(item);
                    481: }
                    482: 
                    483: /*
                    484: **     This can be called for the main list or an anchor's list
2.1       frystyk   485: */
2.3       frystyk   486: PUBLIC void HTCacheClear ARGS1(HTList *, list)
2.1       frystyk   487: {
2.3       frystyk   488:     HTCacheItem * item;
                    489:     while ((item = (HTCacheItem *) HTList_objectAt(list, 0)) != NULL) {
                    490:         HTCache_remove(list, item);
                    491:     }
2.1       frystyk   492: }
                    493: 
                    494: 
2.3       frystyk   495: /*
                    496: **   This function removes ALL cache files known to this session. The anchors
                    497: **   ARE updated, but normally this function is for exiting purposes.
                    498: */
                    499: PUBLIC void HTCacheDeleteAll NOARGS
                    500: {
                    501:     HTCacheItem * item;
                    502:     while ((item = (HTCacheItem *) HTList_objectAt(HTCache, 0)) != NULL) {
                    503:         HTCache_remove(HTCache, item);
                    504:     }
                    505: }
2.1       frystyk   506: 
2.3       frystyk   507: /*  Remove a file from the cache to prevent too many files from being cached
2.1       frystyk   508: */
2.3       frystyk   509: PRIVATE void limit_cache ARGS1(HTList * , list)
2.1       frystyk   510: {
2.3       frystyk   511:     HTList * cur = list;
                    512:     HTCacheItem * item;
                    513:     time_t best_delay = 0;   /* time_t in principle can be any arith type */
                    514:     HTCacheItem* best_item = NULL;
                    515: 
                    516:     if (HTList_count(list) < HTCacheLimit) return;   /* Limit not reached */
                    517: 
                    518:     while (NULL != (item = (HTCacheItem*)HTList_nextObject(cur))) {
                    519:         if (best_delay == 0  ||  item->load_delay < best_delay) {
                    520:             best_delay = item->load_delay;
                    521:             best_item = item;
                    522:         }
                    523:     }
                    524: 
                    525:     if (best_item) HTCache_remove(list, best_item);
2.1       frystyk   526: }
                    527: 
2.3       frystyk   528: /*     Enable Cache
2.1       frystyk   529: **     ------------
2.3       frystyk   530: **     If `cache_root' is NULL then reuse old value or use HT_CACHE_ROOT.
                    531: **     An empty string will make '/' as cache root
2.1       frystyk   532: */
2.3       frystyk   533: PUBLIC BOOL HTCache_enable ARGS1(CONST char *, cache_root)
2.1       frystyk   534: {
2.3       frystyk   535:     if (cache_root)
                    536:        HTCache_setRoot(cache_root);
                    537:     HTCacheEnable = YES;
                    538:     return YES;
2.1       frystyk   539: }
                    540: 
                    541: 
2.3       frystyk   542: /*     Disable Cache
                    543: **     ------------
                    544: **     Turns off the cache. Note that the cache can be disabled and enabled
                    545: **     at any time. The cache root is kept and can be reused during the
                    546: **     execution.
2.1       frystyk   547: */
2.3       frystyk   548: PUBLIC BOOL HTCache_disable NOARGS
2.1       frystyk   549: {
2.3       frystyk   550:     HTCacheEnable = NO;
                    551:     return YES;
                    552: }
2.1       frystyk   553: 
2.3       frystyk   554: /*     Is Cache Enabled
                    555: **     ----------------
                    556: **     Returns YES or NO. Also makes sure that we have a root value
                    557: **     (even though it might be invalid)
                    558: */
                    559: PUBLIC BOOL HTCache_isEnabled NOARGS
                    560: {
2.9     ! frystyk   561:     if (!HTSecure && HTCacheEnable) {
2.3       frystyk   562:        if (!HTCacheRoot)
                    563:            HTCache_setRoot(NULL);
                    564:        return YES;
2.1       frystyk   565:     }
2.3       frystyk   566:     return NO;
2.1       frystyk   567: }
                    568: 
2.3       frystyk   569: 
                    570: /*     Set Cache Root
                    571: **     --------------
                    572: **     If `cache_root' is NULL then the current value (might be a define)
                    573: **     Should we check if the cache_root is actually OK? I think not!
2.1       frystyk   574: */
2.3       frystyk   575: PUBLIC BOOL HTCache_setRoot ARGS1(CONST char *, cache_root)
                    576: {
                    577:     StrAllocCopy(HTCacheRoot, cache_root ? cache_root : HT_CACHE_ROOT);
                    578:     if (*(HTCacheRoot+strlen(HTCacheRoot)-1) != '/')
                    579:        StrAllocCat(HTCacheRoot, "/");
                    580:     if (CACHE_TRACE)
                    581:        fprintf(TDEST, "Cache Root.. Root set to `%s\'\n", HTCacheRoot);
                    582:     return YES;
                    583: }
2.1       frystyk   584: 
2.3       frystyk   585: 
                    586: /*     Get Cache Root
                    587: **     --------------
                    588: */
                    589: PUBLIC CONST char * HTCache_getRoot NOARGS
2.1       frystyk   590: {
2.3       frystyk   591:     return HTCacheRoot;
2.1       frystyk   592: }
                    593: 
                    594: 
2.3       frystyk   595: /*     Free Cache Root
                    596: **     --------------
                    597: **     For clean up memory
2.1       frystyk   598: */
2.3       frystyk   599: PUBLIC void HTCache_freeRoot NOARGS
                    600: {
                    601:     FREE(HTCacheRoot);
                    602: }
2.1       frystyk   603: 
                    604: 
2.3       frystyk   605: /*     Cache Writer
                    606: **     ------------------
                    607: **
2.1       frystyk   608: */
2.3       frystyk   609: PUBLIC HTStream* HTCacheWriter ARGS5(
                    610:        HTRequest *,            request,
                    611:        void *,                 param,
                    612:        HTFormat,               input_format,
                    613:        HTFormat,               output_format,
                    614:        HTStream *,             output_stream)
                    615: 
2.1       frystyk   616: {
2.3       frystyk   617:     char *fnam;
2.1       frystyk   618:     HTStream* me;
                    619: 
2.8       frystyk   620:     if (HTSecure) {
2.3       frystyk   621:        if (CACHE_TRACE)
                    622:            fprintf(TDEST, "Only caching if WWW is run locally.\n");
                    623:        return HTBlackHole();
                    624:     }
2.4       frystyk   625: 
                    626:     /* Get a file name */
                    627:     if ((fnam = HTCache_getName(HTAnchor_physical(request->anchor))) == NULL)
                    628:        return HTBlackHole();
                    629: 
2.1       frystyk   630:     me = (HTStream*)calloc(sizeof(*me),1);
2.3       frystyk   631:     if (me == NULL) outofmem(__FILE__, "CacheWriter");
                    632:     me->isa = &HTFWriter;  
2.1       frystyk   633:     me->end_command = NULL;
2.3       frystyk   634:     me->remove_on_close = NO;  /* If needed, put into end_command */
2.1       frystyk   635:     me->announce = NO;
2.3       frystyk   636:     me->filename = NULL;
2.4       frystyk   637:     if ((me->fp = fopen (fnam, "w")) == NULL) {
2.3       frystyk   638:        HTAlert("Can't open local file for writing.");
                    639:        if (CACHE_TRACE)
                    640:            fprintf(TDEST, "HTStream: can't open %s for writing\n",fnam);
                    641:        free(fnam);
                    642:        free(me);
                    643:        return HTBlackHole();
                    644:     }
                    645:     
                    646:     /* Set up a cache record */
                    647:     if (CACHE_TRACE)
                    648:        fprintf(TDEST, "Cache....... Creating file %s\n", fnam);
2.4       frystyk   649:     if ((me->cache = (HTCacheItem*)calloc(sizeof(*me->cache),1)) == NULL)
                    650:        outofmem(__FILE__, "cache");
2.3       frystyk   651:     time(&me->cache->load_time);
                    652:     StrAllocCopy(me->cache->filename, fnam);
2.4       frystyk   653:     me->cache->format = input_format;
                    654:     me->callback = request->callback;
                    655:     me->request = request;     /* won't be freed */
                    656:     me->filename = fnam;   /* will be freed */
                    657: 
                    658:     /* Make binding to he anchor structure */
2.3       frystyk   659:     me->cache->anchor = request->anchor;
                    660:     if (!request->anchor->cacheItems)
                    661:        request->anchor->cacheItems = HTList_new();
                    662:     HTList_addObject(request->anchor->cacheItems, me->cache);
2.4       frystyk   663: 
                    664:     /* Keep a global list of all cache items */
2.3       frystyk   665:     if (!HTCache) HTCache = HTList_new();
                    666:     HTList_addObject(HTCache, me->cache);
2.4       frystyk   667:     limit_cache(HTCache);               /* Limit number (not size) of files */
2.3       frystyk   668:     
2.1       frystyk   669:     return me;
                    670: }
                    671: 
2.3       frystyk   672: /* ------------------------------------------------------------------------- */
                    673: /*                          FILE WRITER ROUTINES                            */
                    674: /* ------------------------------------------------------------------------- */
                    675: 
                    676: /*     Set TMP Root
                    677: **     --------------
                    678: **     If `tmp_root' is NULL use the current value (might be a define)
                    679: */
                    680: PUBLIC BOOL HTTmp_setRoot ARGS1(CONST char *, tmp_root)
                    681: {
                    682:     StrAllocCopy(HTTmpRoot, tmp_root ? tmp_root : HT_TMP_ROOT);
                    683:     if (*(HTTmpRoot+strlen(HTTmpRoot)-1) != '/')
                    684:        StrAllocCat(HTTmpRoot, "/");
                    685:     if (TRACE)
                    686:        fprintf(TDEST, "Tmp Root.... Root set to `%s\'\n", HTTmpRoot);
                    687:     return YES;
                    688: }
                    689: 
                    690: 
                    691: /*     Get Tmp Root
                    692: **     --------------
2.1       frystyk   693: */
2.3       frystyk   694: PUBLIC CONST char * HTTmp_getRoot NOARGS
                    695: {
                    696:     return HTTmpRoot;
                    697: }
2.1       frystyk   698: 
                    699: 
2.3       frystyk   700: /*     Free Tmp Root
                    701: **     --------------
                    702: **     For clean up memory
                    703: */
                    704: PUBLIC void HTTmp_freeRoot NOARGS
                    705: {
                    706:     FREE(HTTmpRoot);
                    707: }
2.1       frystyk   708: 
2.4       frystyk   709: /*
                    710: **   This function tries really hard to find a non-existent filename relative
                    711: **   to the path given. Returns a string that must be freed by the caller or
                    712: **   NULL on error. The base must be '/' terminated which!
                    713: */
                    714: PRIVATE char *get_filename ARGS3(char *, base, CONST char *, url,
                    715:                                 CONST char *, suffix)
                    716: {
                    717:     char *path=NULL;
                    718:     char filename[40];
                    719:     int hash=0;
                    720: 
                    721:     /* Do this until we find a name that doesn't exist */
                    722:     while (1)
                    723:     {
                    724:        CONST char *ptr=url;
                    725:        for( ; *ptr; ptr++)
                    726:            hash = (int) ((hash * 31 + (* (unsigned char *) ptr)) % HASH_SIZE);
                    727: 
                    728: #ifndef NO_GETPID
                    729:        sprintf(filename, "%d-%d", hash, (int) getpid());
                    730: #else
                    731:        sprintf(filename, "%d-%d", hash, time(NULL));
                    732: #endif
                    733:        StrAllocCopy(path, base);
                    734:        StrAllocCat(path, filename);
                    735:        if (suffix) StrAllocCat(path, suffix);
                    736: 
                    737:        {
                    738:            FILE *fp = fopen(path, "r");
                    739:            if (fp)                          /* This file does already exist */
                    740:                fclose(fp);
                    741:            else
                    742:                break;                                  /* Got the file name */
                    743:        }
                    744:     }
                    745:     return path;
                    746: }
                    747: 
                    748: 
2.1       frystyk   749: /*     Take action using a system command
                    750: **     ----------------------------------
                    751: **
                    752: **     Creates temporary file, writes to it, executes system command
                    753: **     on end-document.  The suffix of the temp file can be given
                    754: **     in case the application is fussy, or so that a generic opener can
                    755: **     be used.
                    756: */
                    757: PUBLIC HTStream* HTSaveAndExecute ARGS5(
                    758:        HTRequest *,            request,
                    759:        void *,                 param,
                    760:        HTFormat,               input_format,
                    761:        HTFormat,               output_format,
                    762:        HTStream *,             output_stream)
                    763: {
                    764:     char *fnam;
                    765:     HTStream* me;
                    766:     
                    767:     if (HTSecure) {
                    768:         HTAlert("Can't save data to file -- please run WWW locally");
                    769:        return HTBlackHole();
                    770:     }
                    771:     
2.3       frystyk   772:     if (!HTTmpRoot) {
2.1       frystyk   773:        if (TRACE) fprintf(TDEST, "Save and execute turned off");
                    774:        return HTBlackHole();
                    775:     }
                    776:        
2.4       frystyk   777:     /* Let's find a hash name for this file */
                    778:     {
2.5       frystyk   779:        char *suffix = HTBind_getSuffix(request->anchor);
2.4       frystyk   780:        fnam = get_filename(HTTmpRoot, HTAnchor_physical(request->anchor),
                    781:                            suffix);
2.5       frystyk   782:        FREE(suffix);
2.4       frystyk   783:        if (!fnam) {
                    784:            HTAlert("Can't find a suitable file name");
                    785:            return HTBlackHole();
                    786:        }
                    787:     }
                    788: 
2.1       frystyk   789:     me = (HTStream*)calloc(sizeof(*me), 1);
                    790:     if (me == NULL) outofmem(__FILE__, "Save and execute");
                    791:     me->isa = &HTFWriter;  
                    792:     me->request = request;     /* won't be freed */    
                    793:     me->fp = fopen (fnam, "w");
                    794:     if (!me->fp) {
                    795:        HTAlert("Can't open temporary file!");
                    796:         free(fnam);
                    797:        free(me);
2.4       frystyk   798:        return HTBlackHole();
2.1       frystyk   799:     }
                    800:     StrAllocCopy(me->filename, fnam);
                    801: 
2.4       frystyk   802:     /* Make command to process file */
2.1       frystyk   803:     me->end_command = (char *) malloc ((strlen((char *) param) + 10 +
                    804:                                        3*strlen(fnam)) * sizeof (char));
                    805:     if (me == NULL) outofmem(__FILE__, "SaveAndExecute");
                    806:     
                    807:     sprintf (me->end_command, (char *) param, fnam, fnam, fnam);
                    808:     me->remove_on_close = NO;
                    809:     me->announce = NO;
                    810:     free (fnam);
                    811:     return me;
                    812: }
                    813: 
                    814: 
                    815: /*     Save Locally
                    816: **     ------------
                    817: **
                    818: **  Bugs:
                    819: **     GUI Apps should open local Save panel here really.
                    820: **
                    821: */
                    822: PUBLIC HTStream* HTSaveLocally ARGS5(
                    823:        HTRequest *,            request,
                    824:        void *,                 param,
                    825:        HTFormat,               input_format,
                    826:        HTFormat,               output_format,
                    827:        HTStream *,             output_stream)  /* Not used */
                    828: 
                    829: {
                    830:     char *fnam = NULL;
                    831:     char *answer = NULL;
                    832:     HTStream* me;
                    833:     
2.8       frystyk   834:     if (HTSecure) {
2.1       frystyk   835:         HTAlert("Can't save data to file -- please run WWW locally");
                    836:        return HTBlackHole();
                    837:     }
                    838: 
2.3       frystyk   839:     if (!HTTmpRoot) {
2.1       frystyk   840:        if (TRACE) fprintf(TDEST, "Save locally turned off");
                    841:        return HTBlackHole();
                    842:     }
                    843:        
2.4       frystyk   844:     /* Let's find a file name for this file */
                    845:     {
2.5       frystyk   846:        char *suffix = HTBind_getSuffix(request->anchor);
2.4       frystyk   847:        fnam = get_filename(HTTmpRoot, HTAnchor_physical(request->anchor),
                    848:                            suffix);
                    849:        answer = HTPrompt("Give name of file to save in", fnam ? fnam : "");
                    850:        if (!answer) {
                    851:            FREE(fnam);
                    852:            return HTBlackHole();
                    853:        }
2.5       frystyk   854:        FREE(suffix);
2.4       frystyk   855:        FREE(fnam);
                    856:     }
                    857:     
2.1       frystyk   858:     me = (HTStream*)calloc(sizeof(*me),1);
                    859:     if (me == NULL) outofmem(__FILE__, "SaveLocally");
                    860:     me->isa = &HTFWriter;  
                    861:     me->announce = YES;
                    862:     
                    863:     me->fp = fopen (answer, "w");
                    864:     if (!me->fp) {
                    865:        HTAlert("Can't open local file to write into.");
                    866:         FREE(answer);
                    867:        free(me);
2.4       frystyk   868:        return HTBlackHole();
2.1       frystyk   869:     }
                    870:     me->callback = NULL;
                    871:     me->request = request;     /* won't be freed */
                    872:     me->filename = answer;     /* Will be freed */
                    873:     return me;
                    874: }
                    875: 
                    876: 
                    877: /*     Save and Call Back
                    878: **     ------------------
                    879: **
                    880: **
                    881: **     The special case is a kludge. Better is everything uses streams
                    882: **     and nothing uses files.  Then this routine will go too. :-))
                    883: */
                    884: PUBLIC HTStream* HTSaveAndCallBack ARGS5(
                    885:        HTRequest *,            request,
                    886:        void *,                 param,
                    887:        HTFormat,               input_format,
                    888:        HTFormat,               output_format,
                    889:        HTStream *,             output_stream)
                    890: {
                    891:    HTStream * me;
                    892:    
                    893:    if (request->using_cache) {  /* Special case! file wanted && cache hit */
                    894:         (*request->callback)(request,
                    895:                         ((HTCacheItem*)request->using_cache)->filename);
2.3       frystyk   896:        return HTBlackHole();
2.1       frystyk   897:    } else {
                    898:        me = HTCacheWriter(request, param,
                    899:                            input_format, output_format, output_stream);
                    900:        if (me) {
                    901:            me->callback = request->callback;
                    902:        }
                    903:    }
                    904:    return me;   
                    905: }
                    906: 

Webmaster