开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
HTFile.c
资源名称：arena-beta-2b-src.tar.gz　[点击查看]
上传用户：zlh9724
上传日期：2007-01-04
资源大小：1991k
文件大小：20k
源码类别：

浏览器

开发平台：

Unix_Linux

HTFile.c：源码内容
  1. /*        HTFile.c
  2. ** FILE ACCESS
  3. **
  4. ** (c) COPYRIGHT MIT 1995.
  5. ** Please first read the full copyright statement in the file COPYRIGH.
  6. **
  7. ** This is unix-specific code in general, with some VMS bits.
  8. ** These are routines for file access used by browsers.
  9. **
  10. ** History:
  11. **    Feb 91 Written Tim Berners-Lee CERN/CN
  12. **    Apr 91 vms-vms access included using DECnet syntax
  13. ** 26 Jun 92 (JFG) When running over DECnet, suppressed FTP.
  14. ** Fixed access bug for relative names on VMS.
  15. **    Sep 93 (MD)  Access to VMS files allows sharing.
  16. ** 15 Nov 93 (MD) Moved HTVMSname to HTVMSUTILS.C
  17. ** 22 Feb 94 (MD)  Excluded two routines if we are not READING directories
  18. ** 18 May 94 (HF) Directory stuff removed and stream handling updated,
  19. ** error messages introduced etc.
  20. **
  21. ** Bugs:
  22. ** FTP: Cannot access VMS files from a unix machine.
  23. **      How can we know that the
  24. ** target machine runs VMS?
  25. */
  27. /* Library Includes */
  28. #include "tcp.h"
  29. #include "HTUtils.h"
  30. #include "HTString.h"
  31. #include "HTParse.h"
  32. #include "HTTCP.h"
  33. #include "HTAnchor.h"
  34. #include "HTAtom.h"
  35. #include "HTWriter.h"
  36. #include "HTFWrite.h"
  37. #include "HTFormat.h"
  38. #include "HTWWWStr.h"
  39. #include "HTAccess.h"
  40. #include "HTMulti.h"
  41. #include "HTIcons.h"
  42. #include "HTDir.h"
  43. #include "HTBind.h"
  44. #include "HTSocket.h"
  45. #include "HTNetMan.h"
  46. #include "HTError.h"
  47. #include "HTReqMan.h"
  48. #include "HTFile.h" /* Implemented here */
  50. /* Final states have negative value */
  51. typedef enum _FileState {
  52.     FS_RETRY = -4,
  53.     FS_ERROR = -3,
  54.     FS_NO_DATA = -2,
  55.     FS_GOT_DATA = -1,
  56.     FS_BEGIN = 0,
  57.     FS_DO_CN,
  58.     FS_NEED_OPEN_FILE,
  59.     FS_NEED_TARGET,
  60.     FS_NEED_BODY,
  61.     FS_PARSE_DIR,
  62.     FS_TRY_FTP
  63. } FileState;
  65. /* This is the context structure for the this module */
  66. typedef struct _file_info {
  67.     FileState state;   /* Current state of the connection */
  68.     char * local; /* Local representation of file name */
  69. #ifdef NO_UNIX_IO    
  70.     FILE * fp;        /* If we can't use sockets on local files */
  71. #endif
  72. } file_info;
  74. /* Local definition */
  75. struct _HTStream {
  76.     CONST HTStreamClass * isa;
  77.     /* ... */
  78. };
  80. PRIVATE BOOL HTTakeBackup = YES;
  82. PRIVATE HTDirReadme dir_readme = HT_DIR_README_TOP;
  83. PRIVATE HTDirAccess dir_access = HT_DIR_OK;
  84. PRIVATE HTDirShow dir_show = HT_DS_SIZE+HT_DS_DATE+HT_DS_DES+HT_DS_ICON;
  85. PRIVATE HTDirKey dir_key = HT_DK_CINS;
  87. /* ------------------------------------------------------------------------- */
  89. /* Directory Access
  90. ** ----------------
  91. */
  92. PUBLIC BOOL HTFile_setDirAccess (HTDirAccess mode)
  93. {
  94.     dir_access = mode;
  95.     return YES;
  96. }
  98. PUBLIC HTDirAccess HTFile_dirAccess (void)
  99. {
  100.     return dir_access;
  101. }
  103. /* Directory Readme
  104. ** ----------------
  105. */
  106. PUBLIC BOOL HTFile_setDirReadme (HTDirReadme mode)
  107. {
  108.     dir_readme = mode;
  109.     return YES;
  110. }
  112. PUBLIC HTDirReadme HTFile_dirReadme (void)
  113. {
  114.     return dir_readme;
  115. }
  117. /* HTFile_readDir
  118. ** --------------
  119. ** Reads the directory "path"
  120. ** Returns:
  121. ** HT_ERROR Error
  122. ** HT_FORBIDDEN Directory reading not allowed
  123. ** HT_LOADED Successfully read the directory
  124. */
  125. PRIVATE int HTFile_readDir (HTRequest * request, file_info *file)
  126. {
  127. #ifndef GOT_READ_DIR
  128.     return HT_ERROR;
  129. #else
  130.     DIR *dp;
  131.     struct stat file_info;
  132.     char *url = HTAnchor_physical(request->anchor);
  133.     char fullname[HT_MAX_PATH+1];
  134.     char *name;
  135.     if (PROT_TRACE) TTYPrint(TDEST, "Reading..... directoryn");
  136.     if (dir_access == HT_DIR_FORBID) {
  137. HTRequest_addError(request, ERR_FATAL, NO, HTERR_FORBIDDEN,
  138.    NULL, 0, "HTFile_readDir");
  139. return HT_FORBIDDEN;
  140.     }
  141.     
  142.     /* Initialize path name for stat() */
  143.     if (*(name = (url+strlen(url)-1)) != '/') {
  144. char *newurl = NULL;
  145. StrAllocCopy(newurl, url);
  146. StrAllocCat(newurl, "/");
  147. HT_FREE(file->local);
  148. file->local = HTWWWToLocal(newurl, "");
  149. HT_FREE(newurl);
  150.     }
  151.     strcpy(fullname, file->local);
  152.     name = fullname+strlen(fullname);  /* Point to end of fullname */
  154.     /* Check if access is enabled */
  155.     if (dir_access == HT_DIR_SELECTIVE) {
  156. strcpy(name, DEFAULT_DIR_FILE);
  157. if (HT_STAT(fullname, &file_info)) {
  158.     if (PROT_TRACE)
  159. TTYPrint(TDEST,
  160. "Read dir.... `%s' not foundn", DEFAULT_DIR_FILE);
  161.     HTRequest_addError(request, ERR_FATAL, NO, HTERR_FORBIDDEN,
  162.        NULL, 0, "HTFile_readDir");
  163.     return HT_FORBIDDEN;
  164. }
  165.     }
  167.     if ((dp = opendir(file->local))) {
  168. STRUCT_DIRENT *dirbuf;
  169. HTDir *dir = HTDir_new(request, dir_show, dir_key);
  170. char datestr[20];
  171. char sizestr[10];
  172. HTFileMode mode;
  173. #ifdef HT_REENTRANT
  174. STRUCT_DIRENT result;     /* For readdir_r */
  175. while ((dirbuf = (STRUCT_DIRENT *) readdir_r(dp, &result)))
  176. #else
  177. while ((dirbuf = readdir(dp)))
  178. #endif /* HT_REENTRANT */
  179. {
  180.     /* Current and parent directories are never shown in list */
  181.     if (
  182. #ifndef __QNX__ /* doesn't return unused directory slots */
  183.                 !dirbuf->d_ino ||
  184. #endif
  185. !strcmp(dirbuf->d_name, ".") || !strcmp(dirbuf->d_name, ".."))
  186. continue;
  188.     /* Make a lstat on the file */
  189.     strcpy(name, dirbuf->d_name);
  190.     if (HT_LSTAT(fullname, &file_info)) {
  191. if (PROT_TRACE)
  192.     TTYPrint(TDEST, "Read dir.... lstat failed: %sn",fullname);
  193. continue;
  194.     }
  196.     /* Convert stat info to fit our setup */
  197.     if (((mode_t) file_info.st_mode & S_IFMT) == S_IFDIR) {
  198. #ifdef VMS
  199. char *dot = strstr(name, ".DIR");      /* strip .DIR part... */
  200. if (dot) *dot = '';
  201. #endif /* VMS */
  202. mode = HT_IS_DIR;
  203. if (dir_show & HT_DS_SIZE) strcpy(sizestr, "-");
  204.     } else {
  205. mode = HT_IS_FILE;
  206. if (dir_show & HT_DS_SIZE)
  207.     HTNumToStr(file_info.st_size, sizestr, 10);
  208.     }
  209.     if (dir_show & HT_DS_DATE)
  210. HTDateDirStr(&file_info.st_mtime, datestr, 20);
  212.     /* Add to the list */
  213.     if (HTDir_addElement(dir, name, datestr, sizestr, mode) != YES)
  214. break;
  215. }
  216. closedir(dp);
  217. HTDir_free(dir);
  218.     } else
  219. HTRequest_addSystemError(request,  ERR_FATAL, errno, NO, "opendir");
  220.     return HT_LOADED;
  221. #endif /* GOT_READ_DIR */
  222. }
  224. /* Determine write access to a file
  225. ** --------------------------------
  226. ** If stat_info is NULL then the function calls stat() on it's own,
  227. ** otherwise it uses the information found in stat_info
  228. ** On exit,
  229. ** return value YES if file can be accessed and can be written to.
  230. **
  231. ** Bugs:
  232. ** 1. No code for non-unix systems.
  233. ** 2. Isn't there a quicker way?
  234. */
  235. PRIVATE BOOL HTEditable (CONST char * filename, struct stat * stat_info)
  236. {
  237. #ifndef NO_UNIX_IO
  238. #ifdef NO_GROUPS
  239.     return NO;    /* Safe answer till we find the correct algorithm */
  240. #else
  241. #ifdef NeXT
  242.     int groups[NGROUPS];
  243. #else
  244.     gid_t groups[NGROUPS];
  245. #endif
  246.     int i;
  247.     uid_t myUid;
  248.     int ngroups; /* The number of groups  */
  249.     struct stat fileStatus;
  250.     struct stat *fileptr = stat_info ? stat_info : &fileStatus;
  251.         
  252.     if (!stat_info) {
  253. if (HT_STAT(filename, &fileStatus))
  254.     return NO;   /* Can't even access file! */
  255.     }
  256.     ngroups = getgroups(NGROUPS, groups); /* Groups to which I belong  */
  257.     myUid = geteuid(); /* Get my user identifier */
  259.     if (PROT_TRACE) {
  260.         int i;
  261. TTYPrint(TDEST, 
  262.     "File mode is 0%o, uid=%d, gid=%d. My uid=%d, %d groups (",
  263.          (unsigned int) fileptr->st_mode, (int) fileptr->st_uid,
  264.     (int) fileptr->st_gid, (int) myUid, ngroups);
  265. for (i=0; i<ngroups; i++) TTYPrint(TDEST, " %d", (int) groups[i]);
  266. TTYPrint(TDEST, ")n");
  267.     }
  268.     
  269.     if (fileptr->st_mode & 0002) /* I can write anyway? */
  270.      return YES;
  272.     if ((fileptr->st_mode & 0200) /* I can write my own file? */
  273.      && (fileptr->st_uid == myUid))
  274.      return YES;
  276.     if (fileptr->st_mode & 0020) /* Group I am in can write? */
  277.     {
  278.     for (i=0; i<ngroups; i++) {
  279.             if (groups[i] == fileptr->st_gid)
  280.         return YES;
  281. }
  282.     }
  283.     if (PROT_TRACE) TTYPrint(TDEST, "tFile is not editable.n");
  284.     return NO; /* If no excuse, can't do */
  285. #endif
  286. #else
  287.     /*
  288.     ** We don't know and can't find out. Can we be sure that when opening
  289.     ** a file in mode "a" that the file is not modified?
  290.     */
  291.     return NO;
  292. #endif /* !NO_UNIX_IO */
  293. }
  296. /* Make a save stream
  297. ** ------------------
  298. **
  299. ** The stream must be used for writing back the file.
  300. ** @@@ no backup done
  301. */
  302. PUBLIC HTStream * HTFileSaveStream (HTRequest * request)
  303. {
  305.     CONST char * addr = HTAnchor_address((HTAnchor*)request->anchor);
  306.     char * filename = HTWWWToLocal(addr, "");
  307.     FILE* fp;
  309. /* @ Introduce CVS handling here one day
  310. */
  311. /* Take a backup before we do anything silly   931205
  312. */        
  313.     if (HTTakeBackup) {
  314. char * p;
  315.      char * backup_filename;
  316.      if ((backup_filename = (char  *) HT_MALLOC(strlen(filename)+2)) == NULL)
  317.          HT_OUTOFMEM("taking backup");
  318. strcpy(backup_filename, filename);
  319. for(p=backup_filename+strlen(backup_filename);; p--) {
  320.     if ((*p=='/') || (p<backup_filename)) {
  321.         p[1]=','; /* Insert comma after slash */
  322. break;
  323.     }
  324.     p[1] = p[0]; /* Move up everything to the right of it */
  325. }
  328. #ifdef VMS
  329. if ((fp=fopen(filename, "r", "shr=put", "shr=upd"))) { /* File exists */
  330. #else /* not VMS */
  331. if ((fp=fopen(filename, "r"))) { /* File exists */
  332. #endif /* not VMS */
  333.     fclose(fp);
  334.     if (PROT_TRACE) TTYPrint(TDEST, "File `%s' existsn", filename);
  335.     if (REMOVE(backup_filename)) {
  336. if (PROT_TRACE) TTYPrint(TDEST, "Backup file `%s' removedn",
  337.    backup_filename);
  338.     }
  339.     if (rename(filename, backup_filename)) { /* != 0 => Failure */
  340. if (PROT_TRACE) TTYPrint(TDEST, "Rename `%s' to `%s' FAILED!n",
  341.    filename, backup_filename);
  342.     } else { /* Success */
  343. if (PROT_TRACE)
  344.     TTYPrint(TDEST, "Renamed `%s' to `%s'n", filename,
  345.     backup_filename);
  346.     }
  347. }
  348.      HT_FREE(backup_filename);
  349.     } /* if take backup */    
  350.     
  351.     if ((fp = fopen(filename, "wb")) == NULL) {
  352. HTRequest_addSystemError(request, ERR_FATAL, errno, NO, "fopen");
  353. return NULL;
  354.     } else
  355.      return HTFWriter_new(request, fp, NO);
  356. }
  359. /* FileCleanup
  360. ** -----------
  361. **      This function closes the connection and frees memory.
  362. **      Returns YES on OK, else NO
  363. */
  364. PRIVATE int FileCleanup (HTRequest *req, int status)
  365. {
  366.     HTNet *net = req->net;
  367.     file_info *file = (file_info *) net->context;
  369.     /* Free stream with data TO Local file system */
  370.     if (HTRequest_isDestination(req))
  371. HTRequest_removeDestination(req);
  372.     else  if (req->input_stream) {
  373. if (status == HT_INTERRUPTED)
  374.     (*req->input_stream->isa->abort)(req->input_stream, NULL);
  375. else
  376.     (*req->input_stream->isa->_free)(req->input_stream);
  377. req->input_stream = NULL;
  378.     }
  380.     if (file) {
  381. #ifdef NO_UNIX_IO
  382. if (file->fp) {
  383.     if (PROT_TRACE)
  384. TTYPrint(TDEST,"FileCleanup. Closing file %pn", file->fp);
  385.     fclose(file->fp);
  386. }
  387. #endif
  388. HT_FREE(file->local);
  389. HT_FREE(file);
  390.     }
  391.     HTNet_delete(net, req->internal ? HT_IGNORE : status);
  392.     return YES;
  393. }
  396. /* Load a document
  397. ** ---------------
  398. **
  399. ** On entry,
  400. ** request This is the request structure
  401. ** On exit,
  402. ** returns HT_ERROR Error has occured in call back
  403. ** HT_OK Call back was OK
  404. */
  405. PUBLIC int HTLoadFile (SOCKET soc, HTRequest * request, SockOps ops)
  406. {
  407.     int status = HT_ERROR;
  408.     HTNet *net = request->net;      /* Generic protocol information */
  409.     file_info *file;       /* Specific access information */
  410.     HTParentAnchor *anchor = HTRequest_anchor(request);
  412.     /*
  413.     ** Initiate a new file structure and bind to request structure
  414.     ** This is actually state FILE_BEGIN, but it can't be in the state
  415.     ** machine as we need the structure first.
  416.     */
  417.     if (ops == FD_NONE) {
  418. if (PROT_TRACE) TTYPrint(TDEST, "HTLoadFile.. Looking for `%s'n",
  419. HTAnchor_physical(anchor));
  420. if ((file = (file_info *) HT_CALLOC(1, sizeof(file_info))) == NULL)
  421.     HT_OUTOFMEM("HTLoadFILE");
  422. file->state = FS_BEGIN;
  423. net->context = file;
  424.     } if (ops == FD_CLOSE) {       /* Interrupted */
  425. HTRequest_addError(request, ERR_FATAL, NO, HTERR_INTERRUPTED,
  426.    NULL, 0, "HTLoadHTTP");
  427. FileCleanup(request, HT_INTERRUPTED);
  428. return HT_OK;
  429.     } else
  430. file = (file_info *) net->context; /* Get existing copy */
  432.     /* Now jump into the machine. We know the state from the previous run */
  433.     while (1) {
  434. switch (file->state) {
  435.   case FS_BEGIN:
  436.     if (HTLib_secure()) {
  437. if (PROT_TRACE)
  438.     TTYPrint(TDEST, "LoadFile.... No access to local file systemn");
  439. file->state = FS_TRY_FTP;
  440. break;
  441.     }
  442.     file->local = HTWWWToLocal(HTAnchor_physical(anchor), "");
  443.     if (!file->local) {
  444. file->state = FS_TRY_FTP;
  445. break;
  446.     }
  448.     /* If cache element then jump directly to OPEN FILE state */
  449.     file->state = HTAnchor_cacheHit(anchor) ?
  450. FS_NEED_OPEN_FILE : FS_DO_CN;
  451.     break;
  453.   case FS_DO_CN:
  454.     /*
  455.     ** If we have to do content negotiation then find the object that
  456.     ** fits best into either what the client has indicated in the
  457.     ** accept headers or what the client has registered on its own.
  458.     ** The object chosen can in fact be a directory! However, content
  459.     ** negotiation only makes sense it we can read the directory!
  460.     ** We stat the file in order to find the size and to see it if
  461.     ** exists.
  462.     */
  463.     {
  464. struct stat stat_info;       /* Contains actual file chosen */
  465. if (request->ContentNegotiation) {
  466.     char *new_path=HTMulti(request,file->local,&stat_info);
  467.     if (new_path) {
  468. HT_FREE(file->local);
  469. file->local = new_path;
  470. HTAnchor_setPhysical(anchor, new_path);
  471.     } else {
  472. file->state = FS_ERROR;
  473. break;
  474.     }
  475. } else {
  476.     if (HT_STAT(file->local, &stat_info) == -1) {
  477. if (PROT_TRACE)
  478.     TTYPrint(TDEST, "HTLoadFile.. Can't stat %sn",
  479.     file->local);
  480. HTRequest_addError(request, ERR_FATAL, NO, HTERR_NOT_FOUND,
  481.    NULL, 0, "HTLoadFile");
  482. file->state = FS_ERROR;
  483. break;
  484.     }
  485. }
  486. /* Check to see if the 'localname' is in fact a directory */
  487. if (((stat_info.st_mode) & S_IFMT) == S_IFDIR)
  488.     file->state = FS_PARSE_DIR;
  489. else {
  490.     /*
  491.     ** If empty file then only serve it if it is editable
  492.     */
  493.     BOOL editable = HTEditable(file->local, &stat_info);
  494.     HTBind_getBindings(anchor);
  495.     if (editable)
  496. HTAnchor_appendMethods(anchor, METHOD_PUT);
  497.     if (stat_info.st_size)
  498. HTAnchor_setLength(anchor, stat_info.st_size);
  500.     /* Done with relevant metainformation in anchor */
  501.     HTAnchor_setHeaderParsed(anchor);
  503.     if (!editable && !stat_info.st_size) {
  504. HTRequest_addError(request, ERR_FATAL, NO, HTERR_NO_CONTENT,
  505.    NULL, 0, "HTLoadFile");
  506. file->state = FS_NO_DATA;
  507.     } else
  508. file->state = FS_NEED_OPEN_FILE;
  509. }
  510.     }
  511.     break;
  513.   case FS_NEED_OPEN_FILE:
  515.     /*
  516.     ** If we have unix file descriptors then use this otherwise use
  517.     ** the ANSI C file descriptors
  518.     */
  519. #ifndef NO_UNIX_IO
  520.     if ((net->sockfd = open(file->local, O_RDONLY)) == -1) {
  521. HTRequest_addSystemError(request, ERR_FATAL, errno, NO, "open");
  522. file->state = FS_ERROR;
  523. break;
  524.     }
  525.     if (PROT_TRACE)
  526. TTYPrint(TDEST,"HTLoadFile.. `%s' opened using socket %d n",
  527. file->local, net->sockfd);
  529.     /* If non-blocking protocol then change socket status
  530.     ** I use FCNTL so that I can ask the status before I set it.
  531.     ** See W. Richard Stevens (Advan. Prog. in UNIX env, p.364)
  532.     ** Be CAREFULL with the old `O_NDELAY' - it wont work as read()
  533.     ** returns 0 when blocking and NOT -1. FNDELAY is ONLY for BSD
  534.     ** and does NOT work on SVR4 systems. O_NONBLOCK is POSIX.
  535.     */
  536. #ifndef NO_FCNTL
  537.     if (!request->net->preemptive) {
  538. if ((status = FCNTL(net->sockfd, F_GETFL, 0)) != -1) {
  539.     status |= O_NONBLOCK;     /* POSIX */
  540.     status = FCNTL(net->sockfd, F_SETFL, status);
  541. }
  542. if (PROT_TRACE) {
  543.     if (status == -1)
  544. TTYPrint(TDEST, "HTLoadFile.. Can't make socket non-blockingn");
  545.     else
  546. TTYPrint(TDEST,"HTLoadFile.. Using NON_BLOCKING I/On");
  547. }
  548.     }
  549. #endif /* NO_FCNTL */
  550. #else
  551. #ifdef VMS
  552.     if (!(file->fp = fopen(file->local,"r","shr=put","shr=upd"))) {
  553. #else
  554. #ifdef WWW_WIN_DLL
  555.     if ((file->fp = HTSocket_DLLHackFopen(file->local,"r")) == NULL) {
  556. #else /* !WWW_WIN_DLL */
  557.     if ((file->fp = fopen(file->local,"r")) == NULL) {
  558. #endif /* !WWW_WIN_DLL */
  559. #endif /* !VMS */
  560. HTRequest_addSystemError(request, ERR_FATAL, errno, NO, "fopen");
  561. file->state = FS_ERROR;
  562. break;
  563.     }
  564.     if (PROT_TRACE)
  565. TTYPrint(TDEST,"HTLoadFile.. `%s' opened using FILE %pn",
  566. file->local, file->fp);
  567. #endif /* !NO_UNIX_IO */
  569.     /* Set up stream TO local file system */
  570.     request->input_stream = HTBufWriter_new(net, YES, 512);
  572.     /*
  573.     ** Set up concurrent read/write if this request isn't the
  574.     ** source for a PUT or POST. As source we don't start reading
  575.     ** before all destinations are ready. If destination then
  576.     ** register the input stream and get ready for read
  577.     */
  578.     if (HTRequest_isDestination(request)) {
  579. HTEvent_Register(net->sockfd, request, (SockOps) FD_READ,
  580.  HTLoadFile, net->priority);
  581. HTRequest_linkDestination(request);
  582.     }
  583.     file->state = FS_NEED_TARGET;
  584.     if (HTRequest_isSource(request) && !HTRequest_destinationsReady(request))
  585. return HT_OK;
  587. #ifndef NO_UNIX_IO
  588.     if (PROT_TRACE) TTYPrint(TDEST, "HTLoadFile.. returningn");
  589.     HTEvent_Register(net->sockfd, request, (SockOps) FD_READ,
  590.      net->cbf, net->priority);
  591.     return HT_WOULD_BLOCK;
  592. #endif
  593.     break;
  595.   case FS_NEED_TARGET:
  596.     /*
  597.     ** Set up read buffer and streams.
  598.     ** If cache element, we know that it's MIME, so call MIME parser
  599.     ** If ANSI then sockfd=INVSOC
  600.     */
  601.     net->isoc = HTInputSocket_new(net->sockfd);
  602.     if (HTAnchor_cacheHit(anchor))HTAnchor_setFormat(anchor, WWW_MIME);
  603.     net->target = HTStreamStack(HTAnchor_format(anchor),
  604. request->output_format,
  605. request->output_stream,
  606. request, YES);
  607.     file->state = net->target ? FS_NEED_BODY : FS_ERROR;
  608.     break;
  610.   case FS_NEED_BODY:
  611. #ifndef NO_UNIX_IO
  612.     status = HTSocketRead(request, net);
  613. #else
  614.     status = HTFileRead(request, net, file->fp);
  615. #endif
  616.     if (status == HT_WOULD_BLOCK)
  617. return HT_OK;
  618.     else if (status == HT_LOADED || status == HT_CLOSED) {
  619. file->state = FS_GOT_DATA;
  620.     } else
  621. file->state = FS_ERROR;
  622.     break;
  624.   case FS_PARSE_DIR:
  625.     status = HTFile_readDir(request, file);
  626.     if (status == HT_LOADED)
  627. file->state = FS_GOT_DATA;
  628.     else
  629. file->state = FS_ERROR;
  630.     break;
  632.   case FS_TRY_FTP:
  633.     {
  634. char *url = HTAnchor_physical(anchor);
  635. HTAnchor *anchor;
  636. char *newname = NULL;
  637. StrAllocCopy(newname, "ftp:");
  638. if (!strncmp(url, "file:", 5))
  639.     StrAllocCat(newname, url+5);
  640. else
  641.     StrAllocCat(newname, url);
  642. anchor = HTAnchor_findAddress(newname);
  643. HTRequest_setAnchor(request, anchor);
  644. HT_FREE(newname);
  645. FileCleanup(request, HT_IGNORE);
  646. return HTLoad(request, YES);
  647.     }
  648.     break;
  650.   case FS_GOT_DATA:
  651.     if (HTRequest_isPostWeb(request)) {
  652. if (HTRequest_isDestination(request)) {
  653.     HTLink *link =
  654. HTAnchor_findLink((HTAnchor *) request->source->anchor,
  655.   (HTAnchor *) anchor);
  656.     HTLink_setResult(link, HT_LINK_OK);
  657. }
  658.     }
  659.     FileCleanup(request, HT_LOADED);
  660.     return HT_OK;
  661.     break;
  663.   case FS_NO_DATA:
  664.     if (HTRequest_isPostWeb(request)) {
  665. if (HTRequest_isDestination(request)) {
  666.     HTLink *link =
  667. HTAnchor_findLink((HTAnchor *) request->source->anchor,
  668.   (HTAnchor *) anchor);
  669.     HTLink_setResult(link, HT_LINK_OK);
  670. }
  671.     }
  672.     FileCleanup(request, HT_NO_DATA);
  673.     return HT_OK;
  674.     break;
  676.   case FS_RETRY:
  677.     if (HTRequest_isPostWeb(request)) {
  678. if (HTRequest_isDestination(request)) {
  679.     HTLink *link =
  680. HTAnchor_findLink((HTAnchor *) request->source->anchor,
  681.   (HTAnchor *) anchor);
  682.     HTLink_setResult(link, HT_LINK_ERROR);
  683. }
  684. HTRequest_killPostWeb(request);
  685.     }
  686.     FileCleanup(request, HT_RETRY);
  687.     return HT_OK;
  688.     break;
  690.   case FS_ERROR:
  691.     if (HTRequest_isPostWeb(request)) {
  692. if (HTRequest_isDestination(request)) {
  693.     HTLink *link =
  694. HTAnchor_findLink((HTAnchor *) request->source->anchor,
  695.   (HTAnchor *) anchor);
  696.     HTLink_setResult(link, HT_LINK_ERROR);
  697. }
  698. HTRequest_killPostWeb(request);
  699.     }
  700.     FileCleanup(request, HT_ERROR);
  701.     return HT_OK;
  702.     break;
  703. }
  704.     } /* End of while(1) */
  705. }