Changeset 0a7278e – RTEMS Project

cpukit/httpd/asp.c

-                      r0893220
+                      r0a7278e
 /*
  *      The ASP module processes ASP pages and executes embedded scripts. It
  *      support an open scripting architecture with in-built support for
+ *      The ASP module processes ASP pages and executes embedded scripts. It
+ *      support an open scripting architecture with in-built support for
  *      Ejscript(TM).
  */
 …
 /*
  *      Process ASP requests and expand all scripting commands. We read the
  *      entire ASP page into memory and then process. If you have really big
+ *      entire ASP page into memory and then process. If you have really big
  *      documents, it is better to make them plain HTML files rather than ASPs.
  */
 …
                                         if (websValid(wp)) {
                                                 if (result) {
                                                         websWrite(wp, T("<h2><b>ASP Error: %s</b></h2>\n"),
+                                                        websWrite(wp, T("<h2><b>ASP Error: %s</b></h2>\n"),
                                                                 result);
                                                         websWrite(wp, T("<pre>%s</pre>"), nextp);
 …
  */
 int websAspDefine(char_t *name,
+int websAspDefine(char_t *name,
         int (*fn)(int ejid, webs_t wp, int argc, char_t **argv))
+{
         return ejSetGlobalFunctionDirect(websAspFunctions, name,
+        return ejSetGlobalFunctionDirect(websAspFunctions, name,
                 (int (*)(int, void*, int, char_t**)) fn);
+}
 …
         a_assert(websValid(wp));
         for (i = 0; i < argc; ) {
                 a_assert(argv);
 …
  */
 static char_t *skipWhite(char_t *s)
+static char_t *skipWhite(char_t *s)
+{
         a_assert(s);

cpukit/httpd/balloc.c

-                      r0893220
+                      r0a7278e
  *      This module implements a very fast block allocation scheme suitable for
  *      ROMed environments. It maintains block class queues for rapid allocation
  *      and minimal fragmentation. This module does not coalesce blocks. The
  *      storage space may be populated statically or via the traditional malloc
  *      mechanisms. Large blocks greater than the maximum class size may be
  *      allocated from the O/S or run-time system via malloc. To permit the use
+ *      and minimal fragmentation. This module does not coalesce blocks. The
+ *      storage space may be populated statically or via the traditional malloc
+ *      mechanisms. Large blocks greater than the maximum class size may be
+ *      allocated from the O/S or run-time system via malloc. To permit the use
  *      of malloc, call bopen with flags set to B_USE_MALLOC (this is the default).
  *      It is recommended that bopen be called first thing in the application.
  *      If it is not, it will be called with default values on the first call to
+ *      It is recommended that bopen be called first thing in the application.
+ *      If it is not, it will be called with default values on the first call to
  *      balloc(). Note that this code is not designed for multi-threading purposes
  *      and it depends on newly declared variables being initialized to zero.
  */
+ */
 /********************************* Includes ***********************************/
 …
 /*
  *      ROUNDUP4(size) returns the next higher integer value of size that is
+ *      ROUNDUP4(size) returns the next higher integer value of size that is
  *      divisible by 4, or the value of size if size is divisible by 4.
  *      ROUNDUP4() is used in aligning memory allocations on 4-byte boundaries.
 …
 /*
  *      Initialize the balloc module. bopen should be called the very first thing
  *      after the application starts and bclose should be called the last thing
  *      before exiting. If bopen is not called, it will be called on the first
  *      allocation with default values. "buf" points to memory to use of size
  *      "bufsize". If buf is NULL, memory is allocated using malloc. flags may
+ *      after the application starts and bclose should be called the last thing
+ *      before exiting. If bopen is not called, it will be called on the first
+ *      allocation with default values. "buf" points to memory to use of size
+ *      "bufsize". If buf is NULL, memory is allocated using malloc. flags may
  *      be set to B_USE_MALLOC if using malloc is okay. This routine will allocate
  *      an initial buffer of size bufsize for use by the application.
 …
 /******************************************************************************/
 /*
  *      Allocate a block of the requested size. First check the block
+ *      Allocate a block of the requested size. First check the block
  *      queues for a suitable one.
  */
 …
                 if (bFreeLeft > memSize) {
 /*
  *                      The q was empty, and the free list has spare memory so
+ *                      The q was empty, and the free list has spare memory so
  *                      create a new block out of the primary free block
  */
 …
                 return;
+        }
 #ifdef B_VERIFY_CAUSES_SEVERE_OVERHEAD
         bFillBlock(bp, memSize);
 …
  *      Duplicate an ascii string, allow NULL pointers and then dup an empty string.
  *      If UNICODE, bstrdup above works with wide chars, so we need this routine
  *      for ascii strings.
+ *      for ascii strings.
  */
 …
 /*
  *      Reallocate a block. Allow NULL pointers and just do a malloc.
  *      Note: if the realloc fails, we return NULL and the previous buffer is
+ *      Note: if the realloc fails, we return NULL and the previous buffer is
  *      preserved.
  */
 …
 /******************************************************************************/
 /*
  *      Find the size of the block to be balloc'ed.  It takes in a size, finds the
+ *      Find the size of the block to be balloc'ed.  It takes in a size, finds the
  *      smallest binary block it fits into, adds an overhead amount and returns.
  *      q is the binary size used to keep track of block sizes in use.  Called
 …
 #ifdef B_STATS
 /*
  *      Statistics. Do output via calling the writefn callback function with
  *      "handle" as the output file handle.
+ *      Statistics. Do output via calling the writefn callback function with
+ *      "handle" as the output file handle.
  */
 …
                 mem = count * (1 << (q + B_SHIFT));
                 total += mem;
                 (*writefn)(handle,
+                (*writefn)(handle,
                         T("%2d %5d   %4d %6d  %4d %5d   %4d\n"),
                         q, 1 << (q + B_SHIFT), count, mem, bStats[q].inuse,
+                        q, 1 << (q + B_SHIFT), count, mem, bStats[q].inuse,
                         bStats[q].inuse * (1 << (q + B_SHIFT)), bStats[q].alloc);
+        }
 …
  *      bFreeSize                       Initial memory reserved with bopen call
  *      bStatsMemMalloc         memory from calls to system MALLOC
  *      bStatsMemMax
+ *      bStatsMemMax
  *      bStatsBallocMax         largest amount of memory from balloc calls
  *      bStatsMemInUse
 …
         (*writefn)(handle, T("Memory currently balloced %7d\n"), bStatsBallocInUse);
         (*writefn)(handle, T("Max blocks allocated      %7d\n"), bStatsBlksMax);
         (*writefn)(handle, T("Maximum stack used        %7d\n"),
+        (*writefn)(handle, T("Maximum stack used        %7d\n"),
                 (int) bStackStart - (int) bStackMin);
 …
         memcpy(files, bStatsFiles, len);
         qsort(files, bStatsFilesMax, sizeof(bStatsFileType), bStatsFileSort);
         (*writefn)(handle, T("\nMemory Currently Allocated\n"));
         total = 0;
         (*writefn)(handle,
+        (*writefn)(handle,
                 T("                      bytes, blocks in use, total times,")
                 T("largest,   q\n"));
 …
                 if (fp->file[0]) {
                         (*writefn)(handle, T("%18s, %7d,         %5d,      %6d, %7d,%4d\n"),
                                 fp->file, fp->allocated, fp->count, fp->times, fp->largest,
+                                fp->file, fp->allocated, fp->count, fp->times, fp->largest,
                                 fp->q);
                         total += fp->allocated;
 …
                         fp = blkp->who;
                         if (gisalnum(*cp)) {
                                 (*writefn)(handle, T("%-50s allocated by %s\n"), cp,
+                                (*writefn)(handle, T("%-50s allocated by %s\n"), cp,
                                         fp->file);
+                        }
 …
 /*
  *      Update the per block stats. Try from the end first
+ *      Update the per block stats. Try from the end first
  */
         for (bp = &bStatsBlks[bStatsBlksMax - 1]; bp >= bStatsBlks; bp--) {
 …
 /*
  *      verifyUsedBlock verifies that a block which was previously allocated is
  *      still uncorrupted.
+ *      still uncorrupted.
  */
 …
  *      First verify all the free blocks.
  */
         for (q = 0; q < B_MAX_CLASS; q++) {
+        for (q = 0; q < B_MAX_CLASS; q++) {
                 for (bp = bQhead[q]; bp != NULL; bp = bp->u.next) {
                         verifyFreeBlock(bp, q);

cpukit/httpd/cgi.c

-                      r0893220
+                      r0a7278e
 /*
  *      This module implements the /cgi-bin handler. CGI processing differs from
  *      goforms processing in that each CGI request is executed as a separate
+ *      goforms processing in that each CGI request is executed as a separate
  *      process, rather than within the webserver process. For each CGI request the
  *      environment of the new process must be set to include all the CGI variables
 …
  *      Process a form request. Returns 1 always to indicate it handled the URL
  */
 int websCgiHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
+int websCgiHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
                 char_t *url, char_t *path, char_t* query)
+{
 …
 #endif /* ! VXWORKS */
 /*
  *      Get the CWD for resetting after launching the child process CGI
 …
  *      Build command line arguments.  Only used if there is no non-encoded
  *      = character.  This is indicative of a ISINDEX query.  POST separators
  *      are & and others are +.  argp will point to a balloc'd array of
+ *      are & and others are +.  argp will point to a balloc'd array of
  *      pointers.  Each pointer will point to substring within the
  *      query string.  This array of string pointers is how the spawn or
  *      exec routines expect command line arguments to be passed.  Since
+ *      query string.  This array of string pointers is how the spawn or
+ *      exec routines expect command line arguments to be passed.  Since
  *      we don't know ahead of time how many individual items there are in
  *      the query string, the for loop includes logic to grow the array
+ *      the query string, the for loop includes logic to grow the array
  *      size via brealloc.
  */
 …
 /*
  *      Add all CGI variables to the environment strings to be passed
  *      to the spawned CGI process.  This includes a few we don't
+ *      to the spawned CGI process.  This includes a few we don't
  *      already have in the symbol table, plus all those that are in
  *      the cgiVars symbol table.  envp will point to a balloc'd array of
+ *      the cgiVars symbol table.  envp will point to a balloc'd array of
  *      pointers.  Each pointer will point to a balloc'd string containing
  *      the keyword value pair in the form keyword=value.  Since we don't
 …
         if (wp->cgiStdin == NULL) {
                 wp->cgiStdin = websGetCgiCommName();
+        }
+        }
         stdIn = wp->cgiStdin;
         stdOut = websGetCgiCommName();
 …
  *      If successful, the cleanup will be done after the process completes.
  */
         if ((pHandle = websLaunchCgiProc(cgiPath, argp, envp, stdIn, stdOut))
+        if ((pHandle = websLaunchCgiProc(cgiPath, argp, envp, stdIn, stdOut))
                 == -1) {
                 websError(wp, 200, T("failed to spawn CGI task"));
 …
         gstat_t sbuf;
         char_t  cgiBuf[FNAMESIZE];
         if ((gstat(cgip->stdOut, &sbuf) == 0) &&
+        if ((gstat(cgip->stdOut, &sbuf) == 0) &&
                 (sbuf.st_size > cgip->fplacemark)) {
                 int fdout;
 …
  */
                                 nTries = 0;
 /*
+/*
  *                              Make sure we didn't miss something during a task switch.
  *                              Maximum wait is 100 times 10 msecs (1 second).
 …
                                 while ((cgip->fplacemark == 0) && (nTries < 100)) {
                                         websCgiGatherOutput(cgip);
 /*
  *                                      There are some cases when we detect app exit
  *                                      before the file is ready.
+/*
+ *                                      There are some cases when we detect app exit
+ *                                      before the file is ready.
  */
                                         if (cgip->fplacemark == 0) {

cpukit/httpd/default.c

-                      r0893220
+                      r0a7278e
  *      Process a default URL request. This will validate the URL and handle "../"
  *      and will provide support for Active Server Pages. As the handler is the
  *      last handler to run, it always indicates that it has handled the URL
  *      by returning 1.
+ *      last handler to run, it always indicates that it has handled the URL
+ *      by returning 1.
  */
 …
  *      Open the document. Stat for later use.
  */
         if (websPageOpen(wp, lpath, path, SOCKET_RDONLY | SOCKET_BINARY,
+        if (websPageOpen(wp, lpath, path, SOCKET_RDONLY | SOCKET_BINARY,
 ) < 0) {
                 websError(wp, 400, T("Cannot open URL <b>%s</b>"), url);
                 return 1;
+        }
+        }
         if (websPageStat(wp, lpath, path, &sbuf) < 0) {
 …
+    *
     *  GoAhead is vulnerable to a directory traversal bug. A request such as
+    *
+    *
     *  GoAhead-server/../../../../../../../ results in an error message
     *  'Cannot open URL'.
 …
     *  web root and read arbitrary files from the server.
     *  Hence a request like:
+    *
+    *
     *  GoAhead-server/..%5C..%5C..%5C..%5C..%5C..%5C/winnt/win.ini returns the
     *  contents of the win.ini file.
 …
       token = gstrchr(token, '\\');
+   }
         token = gstrtok(path, T("/"));
 /*
  *      Look at each directory segment and process "." and ".." segments
  *      Don't allow the browser to pop outside the root web.
+ *      Don't allow the browser to pop outside the root web.
  */
         while (token != NULL) {
 …
 /******************************************************************************/
 /*
+/*
  *      Closing down. Free resources.
  */

cpukit/httpd/ej.h

-                      r0893220
+                      r0a7278e
 /*
+/*
  *      ej.h -- Ejscript(TM) header
+ *
 …
 /******************************** Description *********************************/
 /*
+/*
  *      GoAhead Ejscript(TM) header. This defines the Ejscript API and internal
  *      structures.
 …
 extern int              ejOpenEngine(sym_fd_t variables, sym_fd_t functions);
 extern void             ejCloseEngine(int eid);
 extern int              ejSetGlobalFunction(int eid, char_t *name,
+extern int              ejSetGlobalFunction(int eid, char_t *name,
                                         int (*fn)(int eid, void *handle, int argc, char_t **argv));
 extern void             ejSetVar(int eid, char_t *var, char_t *value);

cpukit/httpd/ejIntrn.h

-                      r0893220
+                      r0a7278e
 /*
+/*
  *      ejIntrn.h -- Ejscript(TM) header
+ *
 …
 /******************************** Description *********************************/
 /*
+/*
  *      GoAhead Ejscript(TM) header. This defines the Ejscript API and internal
  *      structures.
 …
 extern int              ejRemoveGlobalFunction(int eid, char_t *name);
 extern void             *ejGetGlobalFunction(int eid, char_t *name);
 extern int              ejSetGlobalFunctionDirect(sym_fd_t functions, char_t *name,
+extern int              ejSetGlobalFunctionDirect(sym_fd_t functions, char_t *name,
                                         int (*fn)(int eid, void *handle, int argc, char_t **argv));
 extern void     ejError(ej_t* ep, char_t* fmt, ...);

cpukit/httpd/ejlex.c

-                      r0893220
+                      r0a7278e
 /*
  *      Ejscript lexical analyser. This implementes a lexical analyser for a
+ *      Ejscript lexical analyser. This implementes a lexical analyser for a
  *      a subset of the JavaScript language.
  */
 …
                         return TOK_LITERAL;
                 case '0': case '1': case '2': case '3': case '4':
+                case '0': case '1': case '2': case '3': case '4':
                 case '5': case '6': case '7': case '8': case '9':
                         do {
 …
+                                }
+                        }
                         if (! gisalpha(*tokq->servp) && *tokq->servp != '$' &&
+                        if (! gisalpha(*tokq->servp) && *tokq->servp != '$' &&
                                         *tokq->servp != '_') {
                                 ejError(ep, T("Invalid identifier %s"), tokq->servp);
 …
+                        }
 /*
+/*
  *                      Skip white space after token to find out whether this is
  *                      a function or not.
  */
+ */
                         while (c == ' ' || c == '\t' || c == '\r' || c == '\n') {
                                 if ((c = inputGetc(ep)) < 0)
 …
 /******************************************************************************/
 /*
  *      Convert a hex or octal character back to binary, return original char if
+ *      Convert a hex or octal character back to binary, return original char if
  *      not a hex digit
  */

cpukit/httpd/ejparse.c

-                      r0893220
+                      r0a7278e
                 return NULL;
+        }
         if (gstat(path, &sbuf) < 0) {
                 gclose(fd);
 …
                 return NULL;
+        }
         if ((fileBuf = balloc(B_L, sbuf.st_size + 1)) == NULL) {
                 gclose(fd);
 …
                 return NULL;
+        }
         if (gread(fd, fileBuf, sbuf.st_size) != (int)sbuf.st_size) {
                 gclose(fd);
 …
                 return NULL;
+        }
         fileBuf[sbuf.st_size] = '\0';
         gclose(fd);
 …
         void    *endlessLoopTest;
         int             loopCounter;
         a_assert(script);
         if (emsg) {
                 *emsg = NULL;
+        }
+        }
         if ((ep = ejPtr(eid)) == NULL) {

cpukit/httpd/emfdb.c

-                      r0893220
+                      r0a7278e
  */
 static char_t   *basicProdDir = NULL;
+static char_t   *basicProdDir = NULL;
 static char_t   *basicDefaultDir = T("."); /* Default set to current */
 /*
  * hAlloc chain list of table schemas to be closed
+ * hAlloc chain list of table schemas to be closed
  */
 …
 /******************************************************************************/
 /*
  *      Add a schema to the module-internal schema database
+/*
+ *      Add a schema to the module-internal schema database
  */
 …
         a_assert(pTableRegister);
         trace(4, T("DB: Registering database table <%s>\n"),
+        trace(4, T("DB: Registering database table <%s>\n"),
                 pTableRegister->name);
 …
  *      Bump up the size of the table array
  */
         tid = hAllocEntry((void*) &dbListTables,
                 &dbMaxTables, sizeof(dbTable_t));
+        tid = hAllocEntry((void*) &dbListTables,
+                &dbMaxTables, sizeof(dbTable_t));
 /*
 …
                 for (i = 0; (i < pTableRegister->nColumns); i++) {
                         pTable->columnNames[i] =
+                        pTable->columnNames[i] =
                                 bstrdup(B_L, pTableRegister->columnNames[i]);
                         pTable->columnTypes[i] = pTableRegister->columnTypes[i];
 …
  */
 int dbOpen(char_t *tablename, char_t *filename,
+int dbOpen(char_t *tablename, char_t *filename,
                    int (*gettime)(int did), int flags)
+{
         basicProdDir = NULL;
+        basicProdDir = NULL;
         basicDefaultDir = T(".");
         dbMaxTables = 0;
 …
  */
 int dbSearchStr(int did, char_t *tablename,
+int dbSearchStr(int did, char_t *tablename,
         char_t *colName, char_t *value, int flags)
+{
 …
                 return DB_ERR_TABLE_NOT_FOUND;
+        }
         nColumns = pTable->nColumns;
         nRows = pTable->nRows;
 …
                         pRow = pTable->rows[row];
                         if (pRow) {
                                 compareVal = (char_t *)(pRow[column]);
+                                compareVal = (char_t *)(pRow[column]);
                                 if (compareVal && (gstrcmp(compareVal, value) == 0)) {
                                         return row;
 …
  *              Return -2 if search column was not found
  */
                 trace(3, T("DB: Unable to find column <%s> in table <%s>\n"),
+                trace(3, T("DB: Unable to find column <%s> in table <%s>\n"),
                         colName, tablename);
                 return DB_ERR_COL_NOT_FOUND;
 …
                 size = pTable->nColumns * max(sizeof(int), sizeof(char_t *));
                 return hAllocEntry((void***) &(pTable->rows), &(pTable->nRows), size);
+        }
+        }
         return -1;
 …
 /******************************************************************************/
 /*
  *      Delete a row in the table.
+ *      Delete a row in the table.
  */
 …
  */
                         while (column < nColumns) {
                                 if (pRow[column] &&
+                                if (pRow[column] &&
                                         (pTable->columnTypes[column] == T_STRING)) {
                                         bfree(B_L, (char_t *)pRow[column]);
 …
                         bfreeSafe(B_L, pRow);
                         pTable->nRows = hFree((void ***)&pTable->rows, row);
                         trace(5, T("DB: Deleted row <%d> from table <%s>\n"),
+                        trace(5, T("DB: Deleted row <%d> from table <%s>\n"),
                                 row, tablename);
+                }
                 return 0;
         } else {
                 trace(3, T("DB: Unable to delete row <%d> from table <%s>\n"),
+                trace(3, T("DB: Unable to delete row <%d> from table <%s>\n"),
                         row, tablename);
+        }
         return -1;
+}
 …
 /*****************************************************************************/
 /*
  *      Grow the rows in the table to the nominated size.
+ *      Grow the rows in the table to the nominated size.
  */
 …
                 if (nRows >= nNewRows) {
 /*
+/*
  *              If number of rows already allocated exceeds requested number, do nothing
  */
 …
                                 nNewRows, tablename);
                 } else {
                         trace(4, T("DB: Setting rows to <%d> in table <%s>\n"),
+                        trace(4, T("DB: Setting rows to <%d> in table <%s>\n"),
                                 nNewRows, tablename);
                         while (pTable->nRows < nNewRows) {
 …
+                        }
+                }
+        }
+        }
         return nRet;
 …
+{
         int tid;
         a_assert(tablename);
         tid = dbGetTableId(did, tablename);
 …
         int                     colIndex, *pRow, tid;
         dbTable_t       *pTable;
         a_assert(table);
         a_assert(column);
 …
                                 *returnValue = pRow[colIndex];
                                 return 0;
+                        }
+                        }
                         return DB_ERR_ROW_DELETED;
+                }
 …
 /*
  *      The dbWriteInt function writes a value into a table at a given row and
  *      column.  The existence of the row and column is verified before the
+ *      column.  The existence of the row and column is verified before the
  *      write.  0 is returned on succes, -1 is returned on error.
  */
 …
         pTable = dbListTables[tid];
         if (pTable) {
 /*
 …
 /******************************************************************************/
 /*
  *      The dbWriteStr function writes a string value into a table at a given row
  *      and column.  The existence of the row and column is verified before the
+ *      The dbWriteStr function writes a string value into a table at a given row
+ *      and column.  The existence of the row and column is verified before the
  *      write.  The column is also checked to confirm it is a string field.
  *      0 is returned on succes, -1 is returned on error.
 …
         a_assert(key && *key);
         a_assert(value);
         fmtAlloc(&pLineOut, BUF_MAX, T("%s=%s\n"), key, value);
 …
  */
         fmtAlloc(&tmpFile, FNAMESIZE, T("%s/data.tmp"), basicGetProductDir());
         if ((fd = gopen(tmpFile,
+        if ((fd = gopen(tmpFile,
                 O_CREAT | O_TRUNC | O_WRONLY | O_BINARY, 0666)) < 0) {
                 trace(1, T("WARNING: Failed to open file %s\n"), tmpFile);
 …
  *                              write it out.
  */
                                 if ((pRow == NULL) || (pRow[0] == '\0') ||
+                                if ((pRow == NULL) || (pRow[0] == '\0') ||
                                         (*(char_t *)(pRow[0]) == '\0')) {
                                         continue;
 …
  *                              Print the ROW=rowNumber directive to the file
  */
                                 fmtAlloc(&tmpNum, 20, T("%d"), row);
+                                fmtAlloc(&tmpNum, 20, T("%d"), row);
                                 rc = dbWriteKeyValue(fd, KEYWORD_ROW, tmpNum);
                                 bfreeSafe(B_L, tmpNum);
 …
  *                              Print the key-value pairs (COLUMN=value) for data cells
  */
                                 for (column = 0; (column < nColumns) && (rc >= 0);
+                                for (column = 0; (column < nColumns) && (rc >= 0);
                                         column++, colNames++, colTypes++) {
                                         if (*colTypes == T_STRING) {
                                                 rc = dbWriteKeyValue(fd, *colNames,
+                                                rc = dbWriteKeyValue(fd, *colNames,
                                                         (char_t *)(pRow[column]));
                                         } else {
                                                 fmtAlloc(&tmpNum, 20, T("%d"), pRow[column]);
+                                                fmtAlloc(&tmpNum, 20, T("%d"), pRow[column]);
                                                 rc = dbWriteKeyValue(fd, *colNames, tmpNum);
                                                 bfreeSafe(B_L, tmpNum);
 …
                                 if (rc < 0) {
                                         trace(1, T("WARNING: Failed to write to file %s\n"),
+                                        trace(1, T("WARNING: Failed to write to file %s\n"),
                                                 tmpFile);
                                         nRet = -1;
 …
 /******************************************************************************/
 /*
  *      Parse the file. These files consist of key-value pairs, separated by the
+ *      Parse the file. These files consist of key-value pairs, separated by the
  *  "=" sign. Parsing of tables starts with the "TABLE=value" pair, and rows
  *      are parsed starting with the "ROW=value" pair.
 …
+                }
+        }
         return -1;
+}
 /******************************************************************************/
 /*
+/*
  *      Return a pointer to the table name, given its ID
  */
 …
  */
 static int GetColumnIndex(int tid, char_t *colName)
+static int GetColumnIndex(int tid, char_t *colName)
+{
         int                     column;
 …
         int len;
         if (basicProdDir != NULL) {
+        if (basicProdDir != NULL) {
       bfree(B_L, basicProdDir);
+        }
         basicProdDir = bstrdup(B_L, proddir);
 /*

cpukit/httpd/form.c

-                      r0893220
+                      r0a7278e
  *      This module implements the /goform handler. It emulates CGI processing
  *      but performs this in-process and not as an external process. This enables
  *      a very high performance implementation with easy parsing and decoding
+ *      a very high performance implementation with easy parsing and decoding
  *      of query strings and posted data.
  */
 …
  */
 int websFormHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
+int websFormHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
         char_t *url, char_t *path, char_t *query)
+{
 …
 /*
  *      Lookup the C form function first and then try tcl (no javascript support
+ *      Lookup the C form function first and then try tcl (no javascript support
  *      yet).
  */
 …
  */
 int websFormDefine(char_t *name, void (*fn)(webs_t wp, char_t *path,
+int websFormDefine(char_t *name, void (*fn)(webs_t wp, char_t *path,
         char_t *query))
+{

cpukit/httpd/handler.c

-                      r0893220
+                      r0a7278e
 static int              websUrlHandlerSort(const void *p1, const void *p2);
 static int              websPublishHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,
+static int              websPublishHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,
                                 int sid, char_t *url, char_t *path, char_t *query);
 static char_t   *websCondenseMultipleChars(char_t *strToCondense, char_t cCondense);
 …
 /******************************************************************************/
 /*
  *      Define a new URL handler. urlPrefix is the URL prefix to match. webDir is
+ *      Define a new URL handler. urlPrefix is the URL prefix to match. webDir is
  *      an optional root directory path for a web directory. arg is an optional
  *      arg to pass to the URL handler. flags defines the matching order. Valid
  *      flags include WEBS_HANDLER_LAST, WEBS_HANDLER_FIRST. If multiple users
  *      specify last or first, their order is defined alphabetically by the
+ *      flags include WEBS_HANDLER_LAST, WEBS_HANDLER_FIRST. If multiple users
+ *      specify last or first, their order is defined alphabetically by the
  *      urlPrefix.
  */
 int websUrlHandlerDefine(char_t *urlPrefix, char_t *webDir, int arg,
                 int (*handler)(webs_t wp, char_t *urlPrefix, char_t *webdir, int arg,
+                int (*handler)(webs_t wp, char_t *urlPrefix, char_t *webdir, int arg,
                 char_t *url, char_t *path, char_t *query), int flags)
+{
 …
  *      Sort in decreasing URL length order observing the flags for first and last
  */
         qsort(websUrlHandler, websUrlHandlerMax, sizeof(websUrlHandlerType),
+        qsort(websUrlHandler, websUrlHandlerMax, sizeof(websUrlHandlerType),
                 websUrlHandlerSort);
         return 0;
 …
 /******************************************************************************/
 /*
  *      Delete an existing URL handler. We don't reclaim the space of the old
+ *      Delete an existing URL handler. We don't reclaim the space of the old
  *      handler, just NULL the entry. Return -1 if handler is not found.
  */
 int websUrlHandlerDelete(int (*handler)(webs_t wp, char_t *urlPrefix,
+int websUrlHandlerDelete(int (*handler)(webs_t wp, char_t *urlPrefix,
         char_t *webDir, int arg, char_t *url, char_t *path, char_t *query))
+{
 …
+                }
+        }
         return -rc;
+        return -rc;
+}
 …
  */
 static int websPublishHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,
+static int websPublishHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,
         int sid, char_t *url, char_t *path, char_t *query)
+{
 …
 /*
  *      Trim the urlPrefix off the path and set the webdirectory. Add one to step
+ *      Trim the urlPrefix off the path and set the webdirectory. Add one to step
  *      over the trailing '/'
  */
 …
 /*
  *      See if any valid handlers are defined for this request. If so, call them
  *      and continue calling valid handlers until one accepts the request.
+ *      and continue calling valid handlers until one accepts the request.
  *      Return true if a handler was invoked, else return FALSE.
  */
 …
         wp->state = WEBS_PROCESSING;
         websStats.handlerHits++;
         websSetRequestPath(wp, websGetDefaultDir(), NULL);
 …
 /*
  *      We loop over each handler in order till one accepts the request.
+ *      We loop over each handler in order till one accepts the request.
  *      The security handler will handle the request if access is NOT allowed.
  */
 …
                                 first = 0;
+                        }
                         if ((*sp->handler)(wp, sp->urlPrefix, sp->webDir, sp->arg,
+                        if ((*sp->handler)(wp, sp->urlPrefix, sp->webDir, sp->arg,
                                         wp->url, wp->path, wp->query)) {
                                 return 1;
+                        }
                         if (!websValid(wp)) {
                                 trace(0,
+                                trace(0,
                                 T("webs: handler %s called websDone, but didn't return 1\n"),
                                         sp->urlPrefix);
 …
+        }
 /*
  *      If no handler processed the request, then return an error. Note: It is
+ *      If no handler processed the request, then return an error. Note: It is
  *      the handlers responsibility to call websDone
  */
 …
 /*
  *      Look at each directory segment and process "." and ".." segments
  *      Don't allow the browser to pop outside the root web.
+ *      Don't allow the browser to pop outside the root web.
  */
         while (token != NULL) {
 …
                                 *pStr = *pScan;
+                        }
                         pScan++;
                         pStr++;

cpukit/httpd/md5c.c

r0893220	r0a7278e
3	3	* $Id$
4	4	*/
5
	5
6	6	/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
7	7	rights reserved.

cpukit/httpd/misc.c

-                      r0893220
+                      r0a7278e
 #if (defined (WIN) || defined (NW))
         if ((cp = gstrrchr(name, '/')) == NULL &&
+        if ((cp = gstrrchr(name, '/')) == NULL &&
                 (cp = gstrrchr(name, '\\')) == NULL)
 #else
 …
                         int prec = -1;
                         for ( ; c != '\0'; c = *fmt++) {
                                 if (c == '-') {
                                         f |= flag_minus;
                                 } else if (c == '+') {
                                         f |= flag_plus;
                                 } else if (c == ' ') {
                                         f |= flag_space;
                                 } else if (c == '#') {
                                         f |= flag_hash;
                                 } else if (c == '0') {
                                         f |= flag_zero;
+                                if (c == '-') {
+                                        f |= flag_minus;
+                                } else if (c == '+') {
+                                        f |= flag_plus;
+                                } else if (c == ' ') {
+                                        f |= flag_space;
+                                } else if (c == '#') {
+                                        f |= flag_hash;
+                                } else if (c == '0') {
+                                        f |= flag_zero;
                                 } else {
                                         break;
 …
                                         if (f & flag_hash && value != 0) {
                                                 if (c == 'x') {
                                                         put_ulong(&buf, value, 16, 0, T("0x"), width,
+                                                        put_ulong(&buf, value, 16, 0, T("0x"), width,
                                                                 prec, f);
                                                 } else {
                                                         put_ulong(&buf, value, 16, 1, T("0X"), width,
+                                                        put_ulong(&buf, value, 16, 1, T("0X"), width,
                                                                 prec, f);
+                                                }
 …
         int             i;
         if (len < 0) {
                 len = strnlen(s, prec >= 0 ? prec : ULONG_MAX);
         } else if (prec >= 0 && prec < len) {
                 len = prec;
+        if (len < 0) {
+                len = strnlen(s, prec >= 0 ? prec : ULONG_MAX);
+        } else if (prec >= 0 && prec < len) {
+                len = prec;
+        }
         if (width > len && !(f & flag_minus)) {
                 for (i = len; i < width; ++i) {
                         put_char(buf, ' ');
+                }
+        }
         for (i = 0; i < len; ++i) {
                 put_char(buf, s[i]);
+                for (i = len; i < width; ++i) {
+                        put_char(buf, ' ');
+                }
+        }
+        for (i = 0; i < len; ++i) {
+                put_char(buf, s[i]);
+        }
         if (width > len && f & flag_minus) {
                 for (i = len; i < width; ++i) {
                         put_char(buf, ' ');
+                for (i = len; i < width; ++i) {
+                        put_char(buf, ' ');
+                }
+        }
 …
         for (len = 1, x = 1; x < ULONG_MAX / base; ++len, x = x2) {
                 x2 = x * base;
                 if (x2 > value) {
                         break;
+                if (x2 > value) {
+                        break;
+                }
+        }
         zeros = (prec > len) ? prec - len : 0;
         width -= zeros + len;
         if (prefix != NULL) {
                 width -= strnlen(prefix, ULONG_MAX);
+        if (prefix != NULL) {
+                width -= strnlen(prefix, ULONG_MAX);
+        }
         if (!(f & flag_minus)) {
                 if (f & flag_zero) {
                         for (i = 0; i < width; ++i) {
                                 put_char(buf, '0');
+                        for (i = 0; i < width; ++i) {
+                                put_char(buf, '0');
+                        }
                 } else {
                         for (i = 0; i < width; ++i) {
                                 put_char(buf, ' ');
+                        for (i = 0; i < width; ++i) {
+                                put_char(buf, ' ');
+                        }
+                }
+        }
         if (prefix != NULL) {
                 put_string(buf, prefix, -1, 0, -1, flag_none);
+        }
         for (i = 0; i < zeros; ++i) {
                 put_char(buf, '0');
+        if (prefix != NULL) {
+                put_string(buf, prefix, -1, 0, -1, flag_none);
+        }
+        for (i = 0; i < zeros; ++i) {
+                put_char(buf, '0');
+        }
         for ( ; x > 0; x /= base) {
 …
+        }
         if (f & flag_minus) {
                 for (i = 0; i < width; ++i) {
                         put_char(buf, ' ');
+                for (i = 0; i < width; ++i) {
+                        put_char(buf, ' ');
+                }
+        }

cpukit/httpd/ringq.c

-                      r0893220
+                      r0a7278e
  *    |                           |                       |               |
  *  rq->buf                    rq->servp               rq->endp      rq->enduf
+ *
+ *
  *      The queue is empty when servp == endp.  This means that the queue will hold
  *      at most rq->buflen -1 bytes.  It is the filler's responsibility to ensure
 …
  *      ringq should it need to grow to accomodate data being added. "maxsize" is
  *      an upper limit (sanity level) beyond which the q must not grow. Set maxsize
  *      to -1 to imply no upper limit. The buffer for the ringq is always
+ *      to -1 to imply no upper limit. The buffer for the ringq is always
  *      dynamically allocated. Set maxsize
  */
 …
 /******************************************************************************/
 /*
  *      Return the length of the data in the ringq. Users must fill the queue to
+ *      Return the length of the data in the ringq. Users must fill the queue to
  *      a high water mark of at most one less than the queue size.
  */
 …
 /******************************************************************************/
 /*
  *      Add a char to the queue. Note if being used to store wide strings
+ *      Add a char to the queue. Note if being used to store wide strings
  *      this does not add a trailing '\0'. Grow the q as required.
  */
 …
 /******************************************************************************/
 /*
  *      Return the maximum number of bytes the ring q can accept via a single
+ *      Return the maximum number of bytes the ring q can accept via a single
  *      block copy. Useful if the user is doing their own data insertion.
  */
 …
         a_assert(rq);
         a_assert(rq->buflen == (rq->endbuf - rq->buf));
         space = rq->buflen - RINGQ_LEN(rq) - 1;
         in_a_line = rq->endbuf - rq->endp;
 …
 /******************************************************************************/
 /*
  *      Return the maximum number of bytes the ring q can provide via a single
+ *      Return the maximum number of bytes the ring q can provide via a single
  *      block copy. Useful if the user is doing their own data retrieval.
  */

cpukit/httpd/security.c

-                      r0893220
+                      r0a7278e
 /********************************** Defines ***********************************/
 /*
  *      The following #defines change the behaviour of security in the absence
+ *      The following #defines change the behaviour of security in the absence
  *      of User Management.
  *      Note that use of User management functions require prior calling of
 …
  */
 int websSecurityHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
+int websSecurityHandler(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
                                                 char_t *url, char_t *path, char_t *query)
+{
 …
                 return 0;
+        }
 /*
  *      Check to see if URL must be encrypted
 …
                         websStats.access++;
                         websError(wp, 401, T("Access Denied\nUnknown User"));
                         trace(3, T("SEC: Unknown user <%s> attempted to access <%s>\n"),
+                        trace(3, T("SEC: Unknown user <%s> attempted to access <%s>\n"),
                                 userid, path);
                         nRet = 1;
 …
                         a_assert(wp->nonce);
                         a_assert(wp->password);
                         digestCalc = websCalcDigest(wp);
                         a_assert(digestCalc);
 …
 #endif
                         websStats.errors++;
                         websError(wp, 401,
+                        websError(wp, 401,
                                 T("Access to this document requires a password"));
                         nRet = 1;
 …
 /******************************************************************************/
 /*
  *      Store the new password, expect a decoded password. Store in websPassword in
+ *      Store the new password, expect a decoded password. Store in websPassword in
  *      the decoded form.
  */

cpukit/httpd/sock.c

-                      r0893220
+                      r0a7278e
 /*
  *      Posix Socket Module.  This supports blocking and non-blocking buffered
+ *      Posix Socket Module.  This supports blocking and non-blocking buffered
  *      socket I/O.
  */
 …
 /*********************************** Code *************************************/
 /*
  *      Write to a socket. Absorb as much data as the socket can buffer. Block if
  *      the socket is in blocking mode. Returns -1 on error, otherwise the number
+ *      Write to a socket. Absorb as much data as the socket can buffer. Block if
+ *      the socket is in blocking mode. Returns -1 on error, otherwise the number
  *      of bytes written.
  */
 …
 /*
  *      Loop adding as much data to the output ringq as we can absorb. Initiate a
+ *      Loop adding as much data to the output ringq as we can absorb. Initiate a
  *      flush when the ringq is too full and continue. Block in socketFlush if the
  *      socket is in blocking mode.
 …
         char    *byteBuf;
         int             r, len;
         len = gstrlen(buf);
         byteBuf = ballocUniToAsc(buf, len);
 …
  *      Read from a socket. Return the number of bytes read if successful. This
  *      may be less than the requested "bufsize" and may be zero. Return -1 for
  *      errors. Return 0 for EOF. Otherwise return the number of bytes read.
+ *      errors. Return 0 for EOF. Otherwise return the number of bytes read.
  *      If this routine returns zero it indicates an EOF condition.
  *  which can be verified with socketEof()
  *      Note: this ignores the line buffer, so a previous socketGets
  *      which read a partial line may cause a subsequent socketRead to miss some
+ *      which read a partial line may cause a subsequent socketRead to miss some
  *      data. This routine may block if the socket is in blocking mode.
+ *
 …
  *                      This flush is critical for readers of datagram packets. If the
  *                      buffer is not big enough to read the whole datagram in one hit,
  *                      the recvfrom call will fail.
+ *                      the recvfrom call will fail.
  */
                         ringqFlush(rq);
 …
 /*
  *                              If bytesRead is 0, this is EOF since socketRead should never
  *                              be called unless there is data yet to be read.  Set the flag.
+ *                              be called unless there is data yet to be read.  Set the flag.
  *                              Then pass back the number of bytes read.
  */
 …
  *      Get a string from a socket. This returns data in *buf in a malloced string
  *      after trimming the '\n'. If there is zero bytes returned, *buf will be set
  *      to NULL. If doing non-blocking I/O, it returns -1 for error, EOF or when
+ *      to NULL. If doing non-blocking I/O, it returns -1 for error, EOF or when
  *      no complete line yet read. If doing blocking I/O, it will block until an
  *      entire line is read. If a partial line is read socketInputBuffered or
  *      socketEof can be used to distinguish between EOF and partial line still
+ *      entire line is read. If a partial line is read socketInputBuffered or
+ *      socketEof can be used to distinguish between EOF and partial line still
  *      buffered. This routine eats and ignores carriage returns.
  */
 …
                         return rc;
+                }
                 if (rc == 0) {
 /*
 …
+                                        }
                                         continue;
+                                }
+                                }
 #endif
 /*
 …
                                 if (sp->saveMask < 0 ) {
                                         sp->saveMask = sp->handlerMask;
                                         socketRegisterInterest(sp,
+                                        socketRegisterInterest(sp,
                                         sp->handlerMask | SOCKET_WRITABLE);
+                                }
 …
  */
 void socketCreateHandler(int sid, int handlerMask, socketHandler_t handler,
+void socketCreateHandler(int sid, int handlerMask, socketHandler_t handler,
                 int data)
+{
 …
  */
 #ifndef UEMF
 #ifdef WIN
+#ifdef WIN
         if (sp->interestEvents & FD_WRITE) {
                 emfTime_t blockTime = { 0, 0 };
 …
 /******************************************************************************/
 /*
  *              If the sendto failed, swap the first two bytes in the
+ *              If the sendto failed, swap the first two bytes in the
  *              sockaddr structure.  This is a kludge due to a change in
  *              VxWorks between versions 5.3 and 5.4, but we want the
+ *              VxWorks between versions 5.3 and 5.4, but we want the
  *              product to run on either.
  */
 …
                 if ((sp = socketList[i]) == NULL) {
                         continue;
+                }
+                }
                 socketHighestFd = max(socketHighestFd, sp->sock);
+        }

cpukit/httpd/sockGen.c

-                      r0893220
+                      r0a7278e
 /*
  *      Posix Socket Module.  This supports blocking and non-blocking buffered
+ *      Posix Socket Module.  This supports blocking and non-blocking buffered
  *      socket I/O.
  */
 …
                         hostent = gethostbyname(host);
                         if (hostent != NULL) {
                                 memcpy((char *) &sockaddr.sin_addr,
+                                memcpy((char *) &sockaddr.sin_addr,
                                         (char *) hostent->h_addr_list[0],
                                         (size_t) hostent->h_length);
 …
         if (host) {
 /*
  *              Connect to the remote server in blocking mode, then go into
+ *              Connect to the remote server in blocking mode, then go into
  *              non-blocking mode if desired.
  */
 …
+                        }
                         if ((rc = connect(sp->sock, (struct sockaddr *) &sockaddr,
                                 sizeof(sockaddr))) < 0 &&
+                                sizeof(sockaddr))) < 0 &&
                                 (rc = tryAlternateConnect(sp->sock,
                                 (struct sockaddr *) &sockaddr)) < 0) {
 …
                 rc = 1;
                 setsockopt(sp->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&rc, sizeof(rc));
                 if (bind(sp->sock, (struct sockaddr *) &sockaddr,
+                if (bind(sp->sock, (struct sockaddr *) &sockaddr,
                                 sizeof(sockaddr)) < 0) {
                         socketFree(sid);
 …
 /******************************************************************************/
 /*
  *      If the connection failed, swap the first two bytes in the
+ *      If the connection failed, swap the first two bytes in the
  *      sockaddr structure.  This is a kludge due to a change in
  *      VxWorks between versions 5.3 and 5.4, but we want the
+ *      VxWorks between versions 5.3 and 5.4, but we want the
  *      product to run on either.
  */
 …
                 bytesRead = recv(sp->sock, buf, toRead, 0);
+        }
    /*
     * BUG 01865 -- CPU utilization hangs on Windows. The original code used
+    * BUG 01865 -- CPU utilization hangs on Windows. The original code used
     * the 'errno' global variable, which is not set by the winsock functions
     * as it is under *nix platforms. We use the platform independent
     * socketGetError() function instead, which does handle Windows correctly.
+    * socketGetError() function instead, which does handle Windows correctly.
     * Other, *nix compatible platforms should work as well, since on those
     * platforms, socketGetError() just returns the value of errno.
     * Thanks to Jonathan Burgoyne for the fix.
     */
    if (bytesRead < 0)
+   if (bytesRead < 0)
+   {
       *errCode = socketGetError();
       if (*errCode == ECONNRESET)
+      if (*errCode == ECONNRESET)
+      {
          sp->flags |= SOCKET_CONNRESET;
 …
                                 continue;
+                        }
+                }
+                }
                 if (sp->flags & SOCKET_CONNRESET) {
                         socketCloseConnection(sid);
 …
 /******************************************************************************/
 /*
  *      Wait for a handle to become readable or writable and return a number of
+ *      Wait for a handle to become readable or writable and return a number of
  *      noticed events. Timeout is in milliseconds.
  */
 …
                 index = sp->sock / (NBBY * sizeof(fd_mask));
                 bit = 1 << (sp->sock % (NBBY * sizeof(fd_mask)));
 /*
  *              Set the appropriate bit in the ready masks for the sp->sock.
 …
         sid = sp->sid;
         if (sp->currentEvents & SOCKET_READABLE) {
                 if (sp->flags & SOCKET_LISTENING) {
+                if (sp->flags & SOCKET_LISTENING) {
                         socketAccept(sp);
                         sp->currentEvents = 0;
                         return 1;
+                }
+                }
         } else {
 …
  */
         if (sp->handler && (sp->handlerMask & sp->currentEvents)) {
                 (sp->handler)(sid, sp->handlerMask & sp->currentEvents,
+                (sp->handler)(sid, sp->handlerMask & sp->currentEvents,
                         sp->handler_data);
 /*
  *              Make sure socket pointer is still valid, then reset the currentEvents.
  */
+ */
                 if (socketList && sid < socketMax && socketList[sid] == sp) {
                         sp->currentEvents = 0;
 …
         for (i = 0; i < socketMax; i++) {
                 if ((sp = socketList[i]) == NULL ||
+                if ((sp = socketList[i]) == NULL ||
                                 (sp->handlerMask & SOCKET_READABLE) == 0) {
                         continue;

cpukit/httpd/socket.c

-                      r0893220
+                      r0a7278e
 /*
  *      Posix Socket Module.  This supports blocking and non-blocking buffered
+ *      Posix Socket Module.  This supports blocking and non-blocking buffered
  *      socket I/O.
  */
 …
                         hostent = gethostbyname(host);
                         if (hostent != NULL) {
                                 memcpy((char *) &sockaddr.sin_addr,
+                                memcpy((char *) &sockaddr.sin_addr,
                                         (char *) hostent->h_addr_list[0],
                                         (size_t) hostent->h_length);
 …
         if (host) {
 /*
  *              Connect to the remote server in blocking mode, then go into
+ *              Connect to the remote server in blocking mode, then go into
  *              non-blocking mode if desired.
  */
 …
+                        }
                         if ((rc = connect(sp->sock, (struct sockaddr *) &sockaddr,
                                 sizeof(sockaddr))) < 0 &&
+                                sizeof(sockaddr))) < 0 &&
                                 (rc = tryAlternateConnect(sp->sock,
                                 (struct sockaddr *) &sockaddr)) < 0) {
 …
                 rc = 1;
                 setsockopt(sp->sock, SOL_SOCKET, SO_REUSEADDR, (char *)&rc, sizeof(rc));
                 if (bind(sp->sock, (struct sockaddr *) &sockaddr,
+                if (bind(sp->sock, (struct sockaddr *) &sockaddr,
                                 sizeof(sockaddr)) < 0) {
                         socketFree(sid);
 …
 /******************************************************************************/
 /*
  *      If the connection failed, swap the first two bytes in the
+ *      If the connection failed, swap the first two bytes in the
  *      sockaddr structure.  This is a kludge due to a change in
  *      VxWorks between versions 5.3 and 5.4, but we want the
+ *      VxWorks between versions 5.3 and 5.4, but we want the
  *      product to run on either.
  */
 …
                                 continue;
+                        }
+                }
+                }
                 if (sp->currentEvents & sp->handlerMask) {
                         return 1;
 …
 /******************************************************************************/
 /*
  *      Wait for a handle to become readable or writable and return a number of
+ *      Wait for a handle to become readable or writable and return a number of
  *      noticed events. Timeout is in milliseconds.
  */
 …
                 index = sp->sock / (NBBY * sizeof(fd_mask));
                 bit = 1 << (sp->sock % (NBBY * sizeof(fd_mask)));
 /*
  *              Set the appropriate bit in the ready masks for the sp->sock.
 …
     sid = sp->sid;
         if (sp->currentEvents & SOCKET_READABLE) {
                 if (sp->flags & SOCKET_LISTENING) {
+                if (sp->flags & SOCKET_LISTENING) {
                         socketAccept(sp);
                         sp->currentEvents = 0;
                         return 1;
+                }
+                }
         } else {
 …
  */
         if (sp->handler && (sp->handlerMask & sp->currentEvents)) {
                 (sp->handler)(sid, sp->handlerMask & sp->currentEvents,
+                (sp->handler)(sid, sp->handlerMask & sp->currentEvents,
                         sp->handler_data);
 /*
  *              Make sure socket pointer is still valid, then reset the currentEvents.
  */
+ */
                 if (socketList && sid < socketMax && socketList[sid] == sp) {
                         sp->currentEvents = 0;
 …
         for (i = 0; i < socketMax; i++) {
                 if ((sp = socketList[i]) == NULL ||
+                if ((sp = socketList[i]) == NULL ||
                                 (sp->handlerMask & SOCKET_READABLE) == 0) {
                         continue;

cpukit/httpd/uemf.c

-                      r0893220
+                      r0a7278e
 /*#ifdef DEV*/
         } else if (etype == E_ASSERT) {
                 fmtAlloc(&buf, E_MAX_ERROR,
                         T("Assertion %s, failed at %s %d\n"), fmtBuf, E_ARGS);
+                fmtAlloc(&buf, E_MAX_ERROR,
+                        T("Assertion %s, failed at %s %d\n"), fmtBuf, E_ARGS);
 /*#endif*/
         } else if (etype == E_USER) {
 …
     * bfreeSafe(B_L, buf) below will fail, because 'buf' is randomly
     * initialized. To be nice, we format a message saying that this is an
     * unknown message type, and in doing so give buf a valid value. Thanks
+    * unknown message type, and in doing so give buf a valid value. Thanks
     * to Simon Byholm.
     */
 …
  */
 void (*traceSetHandler(void (*function)(int level, char_t *buf)))
+void (*traceSetHandler(void (*function)(int level, char_t *buf)))
         (int level, char *buf)
+{
 …
 /******************************************************************************/
 /*
+/*
  *      Convert a string to upper case
  */
 …
 /*
  *      Convert integer to ascii string. Allow a NULL string in which case we
  *      allocate a dynamic buffer.
+ *      allocate a dynamic buffer.
  */

cpukit/httpd/uemf.h

-                      r0893220
+                      r0a7278e
 /******************************** Description *********************************/
 /*
+/*
  *      GoAhead Web Server header. This defines the Web public APIs
  */
 …
 #endif /* NW */
 #ifdef SCOV5
+#ifdef SCOV5
         #include        <sys/types.h>
         #include        <stdio.h>
 …
 /********************************** Unicode ***********************************/
 /*
  *      Constants and limits. Also FNAMESIZE and PATHSIZE are currently defined
+/*
+ *      Constants and limits. Also FNAMESIZE and PATHSIZE are currently defined
  *      in param.h to be 128 and 512
  */
 …
 /*
  *      Text size of buffer macro. A buffer bytes will hold (size / char size)
  *      characters.
+ *      Text size of buffer macro. A buffer bytes will hold (size / char size)
+ *      characters.
  */
 #define TSZ(x)                          (sizeof(x) / sizeof(char_t))
 …
 /*
  *      Allocation flags
+ *      Allocation flags
  */
 #define VALUE_ALLOCATE          0x1
 …
  *    |                           |                       |               |
  *  rq->buf                    rq->servp               rq->endp      rq->enduf
+ *
+ *
  *      The queue is empty when servp == endp.  This means that the queue will hold
  *      at most rq->buflen -1 bytes.  It is the fillers responsibility to ensure
 …
 /*
  *      Block classes are: 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192,
  *                                         16384, 32768, 65536
+ *      Block classes are: 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192,
+ *                                         16384, 32768, 65536
  */
 typedef struct {
 …
 /******************************************************************************/
 /*
  *      Socket flags
+ *      Socket flags
  */
 …
  *      Handler event masks
  */
 #define SOCKET_READABLE                 0x2             /* Make socket readable */
+#define SOCKET_READABLE                 0x2             /* Make socket readable */
 #define SOCKET_WRITABLE                 0x4             /* Make socket writable */
 #define SOCKET_EXCEPTION                0x8             /* Interested in exceptions */
 …
 typedef void    (*socketHandler_t)(int sid, int mask, int data);
 typedef int             (*socketAccept_t)(int sid, char *ipaddr, int port,
+typedef int             (*socketAccept_t)(int sid, char *ipaddr, int port,
                                         int listenSid);
 typedef struct {
 …
 extern void             socketClose(void);
 extern void             socketCloseConnection(int sid);
 extern void             socketCreateHandler(int sid, int mask, socketHandler_t
+extern void             socketCreateHandler(int sid, int mask, socketHandler_t
                                         handler, int arg);
 extern void             socketDeleteHandler(int sid);
 …
 extern int              socketInputBuffered(int sid);
 extern int              socketOpen(void);
 extern int              socketOpenConnection(char *host, int port,
+extern int              socketOpenConnection(char *host, int port,
                                         socketAccept_t accept, int flags);
 extern void     socketProcess(int hid);
 …
 extern int              socketSetBlock(int sid, int flags);
 extern int              socketGetBlock(int sid);
 extern int              socketAlloc(char *host, int port, socketAccept_t accept,
+extern int              socketAlloc(char *host, int port, socketAccept_t accept,
                                         int flags);
 extern void     socketFree(int sid);
 …
 extern void             trace(int lev, char_t *fmt, ...);
 extern void             traceRaw(char_t *buf);
 extern void             (*traceSetHandler(void (*function)(int level, char_t *buf)))
+extern void             (*traceSetHandler(void (*function)(int level, char_t *buf)))
                                         (int level, char_t *buf);
 extern value_t  valueInteger(long value);
 extern value_t  valueString(char_t *value, int flags);

cpukit/httpd/um.c

-                      r0893220
+                      r0a7278e
 #endif  /* #ifdef UEMF */
 /*
+/*
  *      Database Identifier returned from dbOpen()
  */
 static int              didUM = -1;
 /*
+static int              didUM = -1;
+/*
  *      Configuration database persist filename
  */
 …
 /*********************************** Code *************************************/
 /*
  *      umOpen() registers the UM tables in the fake emf-database
+ *      umOpen() registers the UM tables in the fake emf-database
  */
 …
 /******************************************************************************/
 /*
  *      umClose() frees up the UM tables in the fake emf-database
+ *      umClose() frees up the UM tables in the fake emf-database
  */
 …
         a_assert (saveFilename && *saveFilename);
         trace(3, T("UM: Writing User Configuration to file <%s>\n"),
+        trace(3, T("UM: Writing User Configuration to file <%s>\n"),
                 saveFilename);
 …
         a_assert(saveFilename && *saveFilename);
         trace(3, T("UM: Loading User Configuration from file <%s>\n"),
+        trace(3, T("UM: Loading User Configuration from file <%s>\n"),
                 saveFilename);
 …
 /******************************************************************************/
 /*
  *      Encrypt/Decrypt a text string.
+ *      Encrypt/Decrypt a text string.
  *              Returns the number of characters encrypted.
  */
 …
  *                      Simply use existing character.
  */
                 if (enChar && !gisspace(enChar))
+                if (enChar && !gisspace(enChar))
                         *textString = enChar;
 /*
 …
         row = 0;
 /*
  *      Move through table until we retrieve the first row with non-null
+ *      Move through table until we retrieve the first row with non-null
  *      column data.
  */
         columnData = NULL;
         while ((check = dbReadStr(didUM, tableName, columnName, row++,
+        while ((check = dbReadStr(didUM, tableName, columnName, row++,
                 &columnData)) == 0 || (check == DB_ERR_ROW_DELETED)) {
                 if (columnData && *columnData) {
 …
 /******************************************************************************/
 /*
  *      umGetNextRowData() -    return a pointer to the first non-blank
+ *      umGetNextRowData() -    return a pointer to the first non-blank
  *                                              key value following the given one.
  */
 static char_t *umGetNextRowData(char_t *tableName, char_t *columnName,
+static char_t *umGetNextRowData(char_t *tableName, char_t *columnName,
                                                                 char_t *keyLast)
+{
 …
         key = NULL;
         while ((((check = dbReadStr(didUM, tableName, columnName, row++,
+        while ((((check = dbReadStr(didUM, tableName, columnName, row++,
                 &key)) == 0) || (check == DB_ERR_ROW_DELETED)) &&
                 ((key == NULL) || (gstrcmp(key, keyLast) != 0))) {
 …
  *      Move through table until we retrieve the next row with a non-null key
  */
         while (((check = dbReadStr(didUM, tableName, columnName, row++, &key))
+        while (((check = dbReadStr(didUM, tableName, columnName, row++, &key))
                 == 0) || (check == DB_ERR_ROW_DELETED)) {
                 if (key && *key && (gstrcmp(key, keyLast) != 0)) {
 …
  */
 int     umAddUser(char_t *user, char_t *pass, char_t *group,
+int     umAddUser(char_t *user, char_t *pass, char_t *group,
                           bool_t prot, bool_t disabled)
+{
 …
         bfree(B_L, password);
         dbWriteStr(didUM, UM_USER_TABLENAME, UM_GROUP, row, group);
         dbWriteInt(didUM, UM_USER_TABLENAME, UM_PROT, row, prot);
+        dbWriteInt(didUM, UM_USER_TABLENAME, UM_PROT, row, prot);
         dbWriteInt(didUM, UM_USER_TABLENAME, UM_DISABLE, row, disabled);
 …
         if (umGetUserProtected(user)) {
                 return UM_ERR_PROTECTED;
+        }
+        }
 /*
 …
         if ((row = dbSearchStr(didUM, UM_USER_TABLENAME, UM_NAME, user, 0)) >= 0) {
                 return dbDeleteRow(didUM, UM_USER_TABLENAME, row);
+        }
+        }
         return UM_ERR_NOT_FOUND;
 …
 /*
  *      umGetNextUser() Returns the next user found in the "users" table after
  *                                      the given user.
+ *                                      the given user.
  */
 …
  */
 int     umAddGroup(char_t *group, short priv, accessMeth_t am,
+int     umAddGroup(char_t *group, short priv, accessMeth_t am,
                            bool_t prot, bool_t disabled)
+{
 …
         a_assert(group && *group);
         trace(3, T("UM: Adding group <%s>\n"), group);
 /*
  *      Do not allow duplicates
 …
         if (umGetGroupInUse(group)) {
                 return UM_ERR_IN_USE;
+        }
+        }
 /*
 …
         if (umGetGroupProtected(group)) {
                 return UM_ERR_PROTECTED;
+        }
+        }
 /*
 …
         if (dbSearchStr(didUM, UM_USER_TABLENAME, UM_GROUP, group, 0) >= 0) {
                 return TRUE;
+        }
+        }
 /*
 …
         if (dbSearchStr(didUM, UM_ACCESS_TABLENAME, UM_GROUP, group, 0) >= 0) {
                 return TRUE;
+        }
+        }
         return FALSE;
 …
         if (row >= 0) {
                 return dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_PRIVILEGE, row,
+                return dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_PRIVILEGE, row,
                         (int)privilege);
         } else {
 …
         if (row >= 0) {
                 return dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_DISABLE, row,
+                return dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_DISABLE, row,
                         (int) !enabled);
         } else {
 …
         if (row >= 0) {
                 return dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_PROT, row,
+                return dbWriteInt(didUM, UM_GROUP_TABLENAME, UM_PROT, row,
                         (int) protect);
         } else {
 …
 /******************************************************************************/
 /*
  *      umGetNextAccessLimit() -        return a pointer to the first non-blank
+ *      umGetNextAccessLimit() -        return a pointer to the first non-blank
  *                                                              access limit following the given one
  */
 …
         if (row >= 0) {
                 dbReadInt(didUM, UM_ACCESS_TABLENAME, UM_METHOD, row, &am);
+        }
+        }
         return (accessMeth_t) am;
 …
         if (row >= 0) {
                 return dbWriteInt(didUM, UM_ACCESS_TABLENAME, UM_SECURE, row,
+                return dbWriteInt(didUM, UM_ACCESS_TABLENAME, UM_SECURE, row,
                         (int)secure);
         } else {
 …
         char_t  *urlRet, *urlCheck, *lastChar;
         int             len;
         a_assert(url && *url);
         urlRet = NULL;
 …
                         lastChar--;
                         while ((lastChar >= urlCheck) && ((*lastChar == '/') ||
+                        while ((lastChar >= urlCheck) && ((*lastChar == '/') ||
                                 (*lastChar == '\\'))) {
                                 *lastChar = 0;
 …
+                        }
                         while ((lastChar >= urlCheck) && (*lastChar != '/') &&
+                        while ((lastChar >= urlCheck) && (*lastChar != '/') &&
                                 (*lastChar != '\\')) {
                                 *lastChar = 0;
 …
         accessMeth_t    amRet;
         char_t                  *urlHavingLimit, *group;
         urlHavingLimit = umGetAccessLimit(url);
         if (urlHavingLimit) {
 …
         char_t                  *group, *usergroup, *urlHavingLimit;
         short                   priv;
         a_assert(user && *user);
         a_assert(url && *url);
 …
 /*
  *      If the access method for the URL is AM_NONE then
+ *      If the access method for the URL is AM_NONE then
  *      the file "doesn't exist".
  */
         if (amURL == AM_NONE) {
                 return FALSE;
+        }
 /*
  *      If Access Limit has a group specified, then the user must be a
+        }
+/*
+ *      If Access Limit has a group specified, then the user must be a
  *      member of that group
  */
 …
+                }
 #endif
+        }
 /*
  *      Otherwise, user can access the URL
+        }
+/*
+ *      Otherwise, user can access the URL
  */
         return TRUE;

cpukit/httpd/umui.c

-                      r0893220
+                      r0a7278e
 static void             formDeleteUser(webs_t wp, char_t *path, char_t *query);
 static void             formDisplayUser(webs_t wp, char_t *path, char_t *query);
 static int              aspGenerateUserList(int eid, webs_t wp,
+static int              aspGenerateUserList(int eid, webs_t wp,
                                                                         int argc, char_t **argv);
 static void             formAddGroup(webs_t wp, char_t *path, char_t *query);
 static void             formDeleteGroup(webs_t wp, char_t *path, char_t *query);
 static int              aspGenerateGroupList(int eid, webs_t wp,
+static int              aspGenerateGroupList(int eid, webs_t wp,
                                                                          int argc, char_t **argv);
 static void             formAddAccessLimit(webs_t wp, char_t *path, char_t *query);
 static void             formDeleteAccessLimit(webs_t wp, char_t *path, char_t *query);
 static int              aspGenerateAccessLimitList(int eid, webs_t wp,
+static int              aspGenerateAccessLimitList(int eid, webs_t wp,
                                                                                    int argc, char_t **argv);
 static int              aspGenerateAccessMethodList(int eid, webs_t wp,
+static int              aspGenerateAccessMethodList(int eid, webs_t wp,
                                                                                         int argc, char_t **argv);
 static int              aspGeneratePrivilegeList(int eid, webs_t wp,
+static int              aspGeneratePrivilegeList(int eid, webs_t wp,
                                                                                  int argc, char_t **argv);
 …
         a_assert(wp);
         userid = websGetVar(wp, T("user"), T(""));
         pass1 = websGetVar(wp, T("password"), T(""));
         pass2 = websGetVar(wp, T("passconf"), T(""));
         group = websGetVar(wp, T("group"), T(""));
         enabled = websGetVar(wp, T("enabled"), T(""));
         ok = websGetVar(wp, T("ok"), T(""));
+        userid = websGetVar(wp, T("user"), T(""));
+        pass1 = websGetVar(wp, T("password"), T(""));
+        pass2 = websGetVar(wp, T("passconf"), T(""));
+        group = websGetVar(wp, T("group"), T(""));
+        enabled = websGetVar(wp, T("enabled"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);
 …
         a_assert(wp);
         userid = websGetVar(wp, T("user"), T(""));
         ok = websGetVar(wp, T("ok"), T(""));
+        userid = websGetVar(wp, T("user"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);
 …
         a_assert(wp);
         userid = websGetVar(wp, T("user"), T(""));
         ok = websGetVar(wp, T("ok"), T(""));
+        userid = websGetVar(wp, T("user"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);
 …
         a_assert(wp);
         nBytes = websWrite(wp,
+        nBytes = websWrite(wp,
                 T("<SELECT NAME=\"user\" SIZE=\"3\" TITLE=\"Select a User\">"));
         row = 0;
 …
         while (userid && (nBytes > 0)) {
                 nBytes = websWrite(wp, T("<OPTION VALUE=\"%s\">%s\n"),
+                nBytes = websWrite(wp, T("<OPTION VALUE=\"%s\">%s\n"),
                         userid, userid);
                 userid = umGetNextUser(userid);
 …
         a_assert(wp);
         group = websGetVar(wp, T("group"), T(""));
         method = websGetVar(wp, T("method"), T(""));
         enabled = websGetVar(wp, T("enabled"), T(""));
         privilege = websGetVar(wp, T("privilege"), T(""));
         ok = websGetVar(wp, T("ok"), T(""));
+        group = websGetVar(wp, T("group"), T(""));
+        method = websGetVar(wp, T("method"), T(""));
+        enabled = websGetVar(wp, T("enabled"), T(""));
+        privilege = websGetVar(wp, T("privilege"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);
 …
                                 group, nCheck);
                 } else {
                         websWrite(wp, T("Group, \"%s\" was successfully added."),
+                        websWrite(wp, T("Group, \"%s\" was successfully added."),
                                 group);
+                }
 …
         a_assert(wp);
         group = websGetVar(wp, T("group"), T(""));
         ok = websGetVar(wp, T("ok"), T(""));
+        group = websGetVar(wp, T("group"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);
 …
         row = 0;
         nBytesSent = 0;
         nBytes = websWrite(wp,
+        nBytes = websWrite(wp,
                 T("<SELECT NAME=\"group\" SIZE=\"3\" TITLE=\"Select a Group\">"));
 /*
 …
         a_assert(wp);
         url = websGetVar(wp, T("url"), T(""));
         group = websGetVar(wp, T("group"), T(""));
         method = websGetVar(wp, T("method"), T(""));
         secure = websGetVar(wp, T("secure"), T(""));
         ok = websGetVar(wp, T("ok"), T(""));
+        url = websGetVar(wp, T("url"), T(""));
+        group = websGetVar(wp, T("group"), T(""));
+        method = websGetVar(wp, T("method"), T(""));
+        secure = websGetVar(wp, T("secure"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);
 …
         a_assert(wp);
         url = websGetVar(wp, T("url"), T(""));
         ok = websGetVar(wp, T("ok"), T(""));
+        url = websGetVar(wp, T("url"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);
 …
                 websWrite(wp, T("Delete Access Limit Cancelled"));
         } else if (umDeleteAccessLimit(url) != 0) {
                 websWrite(wp, T("ERROR: Unable to delete Access Limit for [%s]"),
+                websWrite(wp, T("ERROR: Unable to delete Access Limit for [%s]"),
                         url);
         } else {
                 websWrite(wp, T("Access Limit for [%s], was successfully deleted."),
+                websWrite(wp, T("Access Limit for [%s], was successfully deleted."),
                         url);
+        }
 …
  */
 static int aspGenerateAccessLimitList(int eid, webs_t wp,
+static int aspGenerateAccessLimitList(int eid, webs_t wp,
                                                                           int argc, char_t **argv)
+{
 …
         row = nBytesSent = 0;
         url = umGetFirstAccessLimit();
         nBytes = websWrite(wp,
+        nBytes = websWrite(wp,
                 T("<SELECT NAME=\"url\" SIZE=\"3\" TITLE=\"Select a URL\">"));
 …
  */
 static int aspGenerateAccessMethodList(int eid, webs_t wp,
+static int aspGenerateAccessMethodList(int eid, webs_t wp,
                                                                            int argc, char_t **argv)
+{
 …
         a_assert(wp);
         nBytes = websWrite(wp,
+        nBytes = websWrite(wp,
                 T("<SELECT NAME=\"method\" SIZE=\"3\" TITLE=\"Select a Method\">"));
         nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">FULL ACCESS\n"),
+        nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">FULL ACCESS\n"),
                 AM_FULL);
         nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">BASIC ACCESS\n"),
+        nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">BASIC ACCESS\n"),
                 AM_BASIC);
         nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\" SELECTED>DIGEST ACCESS\n"),
+        nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\" SELECTED>DIGEST ACCESS\n"),
                 AM_DIGEST);
         nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">NO ACCESS\n"),
+        nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">NO ACCESS\n"),
                 AM_NONE);
         nBytes += websWrite(wp, T("</SELECT>"));
 …
  */
 static int aspGeneratePrivilegeList(int eid, webs_t wp,
+static int aspGeneratePrivilegeList(int eid, webs_t wp,
                                                                         int argc, char_t **argv)
+{
 …
         nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">READ\n"), PRIV_READ);
         nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">EXECUTE\n"), PRIV_WRITE);
         nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">ADMINISTRATE\n"),
+        nBytes += websWrite(wp, T("<OPTION VALUE=\"%d\">ADMINISTRATE\n"),
                 PRIV_ADMIN);
         nBytes += websWrite(wp, T("</SELECT>"));
 …
         a_assert(wp);
         ok = websGetVar(wp, T("ok"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);
 …
         a_assert(wp);
         ok = websGetVar(wp, T("ok"), T(""));
+        ok = websGetVar(wp, T("ok"), T(""));
         websHeader(wp);

cpukit/httpd/url.c

-                      r0893220
+                      r0a7278e
                 return buf;
+        }
         if (websUrlParse(url, &parsebuf, NULL, NULL, NULL, NULL, NULL,
+        if (websUrlParse(url, &parsebuf, NULL, NULL, NULL, NULL, NULL,
                         NULL, &ext) < 0) {
                 gstrcpy(buf, T("text/plain"));
 …
  */
 int websUrlParse(char_t *url, char_t **pbuf, char_t **phost, char_t **ppath,
         char_t **pport, char_t **pquery, char_t **pproto, char_t **ptag,
+int websUrlParse(char_t *url, char_t **pbuf, char_t **phost, char_t **ppath,
+        char_t **pport, char_t **pquery, char_t **pproto, char_t **ptag,
         char_t **pext)
+{
 …
                 if ((cp = gstrchr(tok, '/')) != NULL) {
 /*
  *                      If a full URL is supplied, we need to copy the host and port
+ *                      If a full URL is supplied, we need to copy the host and port
  *                      portions into static buffers.
  */
 …
                 path = tok;
                 tok = query;
+        }
+        }
 /*

cpukit/httpd/wbase64.c

-                      r0893220
+                      r0a7278e
 , 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
         -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
 , 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
         -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
 , 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
 …
                                         c, i);
                                 return -1;
+                        }
+                        }
                         shiftbuf = shiftbuf | (c << shift);
                         shift -= 6;

cpukit/httpd/webcomp.c

-                      r0893220
+                      r0a7278e
         time(&now);
         fprintf(stdout, "/*\n * webrom.c -- Compiled Web Pages\n *\n");
         fprintf(stdout, " * Compiled by GoAhead WebCompile: %s */\n\n",
+        fprintf(stdout, " * Compiled by GoAhead WebCompile: %s */\n\n",
                 gctime(&now));
         fprintf(stdout, "#include \"wsIntrn.h\"\n\n");
 …
                 if (gstat(file, &sbuf) == 0 && sbuf.st_mode & S_IFDIR) {
                         continue;
+                }
+                }
                 if ((fd = gopen(file, O_RDONLY | O_BINARY)) < 0) {
                         fprintf(stderr, "Can't open file %s\n", file);
 …
                         continue;
+                }
                 fprintf(stdout, "    { T(\"/%s\"), page_%d, %d },\n", cp, nFile,
+                fprintf(stdout, "    { T(\"/%s\"), page_%d, %d },\n", cp, nFile,
                         sbuf.st_size);
                 nFile++;
+        }
         fclose(lp);
+        fclose(lp);
         fprintf(stdout, "    { 0, 0, 0 },\n");
         fprintf(stdout, "};\n");

cpukit/httpd/webmain.c

-                      r0893220
+                      r0a7278e
 /* The following holds the pointer to an allocated websTimer_t structure .
  * Using this method only one timer can be active at a time, but
  * for the WebServer, this should be OK.
+ * for the WebServer, this should be OK.
  */
 websTimer_t *tp;
 …
 static timer_t timer_id;
 static void rtems_httpd_daemon(rtems_task_argument args);
 /*********************************** Code *************************************/
 /*
 …
    **********************************************************************/
   priority = 40;
   sc = rtems_task_create(rtems_build_name('H', 'T', 'P', 'D'),
                          priority, 8*1024,
 …
+   {
       return(RTEMS_UNSATISFIED);
+   }
+   }
    return(RTEMS_SUCCESSFUL);
 …
+{
 /*
  *      Initialize the memory allocator. Allow use of malloc and start with a
+ *      Initialize the memory allocator. Allow use of malloc and start with a
  *      10K heap.
  */
 …
 /*
  *      Define the local Ip address, host name, default home page and the
+ *      Define the local Ip address, host name, default home page and the
  *      root web directory.
  */
 …
                 return -1;
+                }
 /*      intaddr.s_addr = (unsigned long) hostGetByName(host); */
         if ((hp = gethostbyname(host)) == NULL) {
 …
         websSetPassword(password);
 /*
+/*
  *      Open the web server on the given port. If that port is taken, try
  *      the next sequential port for up to "retries" attempts.
 …
 /*
  *      First create the URL handlers. Note: handlers are called in sorted order
  *      with the longest path handler examined first. Here we define the security
+ *      with the longest path handler examined first. Here we define the security
  *      handler, forms handler and the default web page handler.
  */
         websUrlHandlerDefine(T(""), NULL, 0, websSecurityHandler,
+        websUrlHandlerDefine(T(""), NULL, 0, websSecurityHandler,
                 WEBS_HANDLER_FIRST);
         websUrlHandlerDefine(T("/goform"), NULL, 0, websFormHandler, 0);
         websUrlHandlerDefine(T(""), NULL, 0, websDefaultHandler,
                 WEBS_HANDLER_LAST);
+        websUrlHandlerDefine(T(""), NULL, 0, websDefaultHandler,
+                WEBS_HANDLER_LAST);
 /*
 …
  *      Create a handler for the default home page
  */
         websUrlHandlerDefine(T("/"), NULL, 0, websHomePageHandler, 0);
+        websUrlHandlerDefine(T("/"), NULL, 0, websHomePageHandler, 0);
         return 0;
+}
 …
 /*
  *      Test Javascript binding for ASP. This will be invoked when "aspTest" is
  *      embedded in an ASP page. See web/asp.asp for usage. Set browser to
+ *      embedded in an ASP page. See web/asp.asp for usage. Set browser to
  *      "localhost/asp.asp" to test.
  */
 …
         char_t  *name, *address;
         name = websGetVar(wp, T("name"), T("Joe Smith"));
         address = websGetVar(wp, T("address"), T("1212 Milky Way Ave."));
+        name = websGetVar(wp, T("name"), T("Joe Smith"));
+        address = websGetVar(wp, T("address"), T("1212 Milky Way Ave."));
         websHeader(wp);
 …
                 return NULL;
+        }
 #if 0
         act.sa_flags = 0;
 …
 /* Copy the timer structure to a local first and delete it before calling
  * the function, since the function could create another timer.  In this
+ * the function, since the function could create another timer.  In this
  * implementation, only one timer can be allocated at a time.
  */
 …
 #if B_STATS
 static void memLeaks()
+static void memLeaks()
+{
         int             fd=1;

cpukit/httpd/webs.c

-                      r0893220
+                      r0a7278e
  *      Optional request log support
  */
         websLogFd = gopen(websLogname, O_CREAT | O_TRUNC | O_APPEND | O_WRONLY,
+        websLogFd = gopen(websLogname, O_CREAT | O_TRUNC | O_APPEND | O_WRONLY,
 );
         a_assert(websLogFd >= 0);
 #endif
         return websOpenListen(port, retries);
+}
 …
         websCloseListen();
 /*
+/*
  *      Close each open browser connection and free all resources
  */
 …
                         orig, port - 1);
                 return -1;
+        }
+        }
 /*
 …
         } else {
                 fmtAlloc(&websHostUrl, WEBS_MAX_URL + 80, T("%s:%d"), websHost, port);
                 fmtAlloc(&websIpaddrUrl, WEBS_MAX_URL + 80, T("%s:%d"),
+                fmtAlloc(&websIpaddrUrl, WEBS_MAX_URL + 80, T("%s:%d"),
                         websIpaddr, port);
+        }
 …
  *      to know for permitting administrative operations only for local access
  */
         if (gstrcmp(wp->ipaddr, T("127.0.0.1")) == 0 ||
                         gstrcmp(wp->ipaddr, websIpaddr) == 0 ||
+        if (gstrcmp(wp->ipaddr, T("127.0.0.1")) == 0 ||
+                        gstrcmp(wp->ipaddr, websIpaddr) == 0 ||
                         gstrcmp(wp->ipaddr, websHost) == 0) {
                 wp->flags |= WEBS_LOCAL_REQUEST;
 …
         if (mask & SOCKET_READABLE) {
                 websReadEvent(wp);
+        }
+        }
         if (mask & SOCKET_WRITABLE) {
                 if (websValid(wp) && wp->writeSocket) {
                         (*wp->writeSocket)(wp);
+                }
+        }
+        }
+}
 …
 /*
  *      The webs read handler. This is the primary read event loop. It uses a
  *      state machine to track progress while parsing the HTTP request.
+ *      state machine to track progress while parsing the HTTP request.
  *      Note: we never block as the socket is always in non-blocking mode.
  */
 …
 /*
  *              Get more input into "text". Returns 0, if more data is needed
  *              to continue, -1 if finished with the request, or 1 if all
+ *              to continue, -1 if finished with the request, or 1 if all
  *              required data is available for current state.
  */
 …
 /*
  *              This is the state machine for the web server.
+ *              This is the state machine for the web server.
  */
                 switch(wp->state) {
 …
                         wp->state = WEBS_HEADER;
                         break;
                 case WEBS_HEADER:
 /*
 …
                                 nbytes += 1;
  */
                         } else
+                        } else
 #endif
                         if (wp->query) {
                                 if (wp->query[0] && !(wp->flags & WEBS_POST_DATA)) {
 /*
  *                                      Special case where the POST request also had query data
+ *                                      Special case where the POST request also had query data
  *                                      specified in the URL, ie. url?query_data. In this case
  *                                      the URL query data is separated by a '&' from the posted
 …
 /******************************************************************************/
 /*
  *      Get input from the browser. Return TRUE (!0) if the request has been
  *      handled. Return -1 on errors or if the request has been processed,
+ *      Get input from the browser. Return TRUE (!0) if the request has been
+ *      handled. Return -1 on errors or if the request has been processed,
  *      1 if input read, and 0 to instruct the caller to call again for more input.
+ *
  *      Note: socketRead will Return the number of bytes read if successful. This
  *      may be less than the requested "bufsize" and may be zero. It returns -1 for
  *      errors. It returns 0 for EOF. Otherwise it returns the number of bytes
  *      read. Since this may be zero, callers should use socketEof() to
+ *      errors. It returns 0 for EOF. Otherwise it returns the number of bytes
+ *      read. Since this may be zero, callers should use socketEof() to
  *      distinguish between this and EOF.
  */
 static int websGetInput(webs_t wp, char_t **ptext, int *pnbytes)
+static int websGetInput(webs_t wp, char_t **ptext, int *pnbytes)
+{
         char_t  *text;
 …
                 } else {                                                                /* Valid data */
 /*
  *                      Convert to UNICODE if necessary.  First be sure the string
+ *                      Convert to UNICODE if necessary.  First be sure the string
  *                      is NULL terminated.
  */
 …
                         if (wp->flags & WEBS_SECURE) {
 /*
  *                              If state is WEBS_BEGIN and the request is secure, a -1 will
+ *                              If state is WEBS_BEGIN and the request is secure, a -1 will
  *                              usually indicate SSL negotiation
  */
 …
                         if (eof) {
 /*
  *                              If this is a post request without content length, process
  *                              the request as we now have all the data. Otherwise just
+ *                              If this is a post request without content length, process
+ *                              the request as we now have all the data. Otherwise just
  *                              close the connection.
  */
 …
  *                      this code assumes we were only expecting a one line header, which
  *                      is not necessarily the case. So we weren't processing the whole
  *                      header and weren't fufilling requests properly.
+ *                      header and weren't fufilling requests properly.
  */
 #ifdef UNUSED
 …
  */
         host = path = port = proto = query = ext = NULL;
         if (websUrlParse(url, &buf, &host, &path, &port, &query, &proto,
+        if (websUrlParse(url, &buf, &host, &path, &port, &query, &proto,
                         NULL, &ext) < 0) {
                 websError(wp, 400, T("Bad URL format"));
 …
         wp->protocol = bstrdup(B_L, proto);
         wp->protoVersion = bstrdup(B_L, protoVer);
         if ((testPort = socketGetPort(wp->listenSid)) >= 0) {
                 wp->port = testPort;
 …
 #ifdef WEBS_PROXY_SUPPORT
 /*
  *      Determine if this is a request for local webs data. If it is not a proxied
+ *      Determine if this is a request for local webs data. If it is not a proxied
  *      request from the browser, we won't see the "http://" or the system name, so
  *      we assume it must be talking to us directly for local webs data.
  *      Note: not fully implemented yet.
  */
         if (gstrstr(wp->url, T("http://")) == NULL ||
                 ((gstrcmp(wp->host, T("localhost")) == 0 ||
+        if (gstrstr(wp->url, T("http://")) == NULL ||
+                ((gstrcmp(wp->host, T("localhost")) == 0 ||
                         gstrcmp(wp->host, websHost) == 0) && (wp->port == websPort))) {
                 wp->flags |= WEBS_LOCAL_PAGE;
 …
         websSetVar(wp, T("HTTP_AUTHORIZATION"), T(""));
 /*
+/*
  *      Parse the header and create the Http header keyword variables
  *      We rewrite the header as we go for non-local requests.  NOTE: this
 …
                         authType = bstrdup (B_L, value);
                         a_assert (authType);
 /*
+/*
  *                      Truncate authType at the next non-alpha character
  */
 …
          if (wp->clen > 0)
+         {
                            wp->flags |= WEBS_CLEN;
+                           wp->flags |= WEBS_CLEN;
                            websSetVar(wp, T("CONTENT_LENGTH"), value);
+         }
 …
                 if (*keyword) {
 /*
  *                      If keyword has already been set, append the new value to what has
+ *                      If keyword has already been set, append the new value to what has
  *                      been stored.
  */
 …
 /*
  *      Define a webs (CGI) variable for this connection. Also create in relevant
  *      scripting engines. Note: the incoming value may be volatile.
+ *      scripting engines. Note: the incoming value may be volatile.
  */
 …
         a_assert(websValid(wp));
         a_assert(var && *var);
         if ((sp = symLookup(wp->cgiVars, var)) != NULL) {
                 a_assert(sp->content.type == string);
 …
         a_assert(websValid(wp));
         a_assert(var && *var);
         if (gstrcmp(value, websGetVar(wp, var, T(" __UNDEF__ "))) == 0) {
                 return 1;
 …
 /******************************************************************************/
 /*
  *      Output a HTTP response back to the browser. If redirect is set to a
+ *      Output a HTTP response back to the browser. If redirect is set to a
  *      URL, the browser will be sent to this location.
  */
 …
+                }
 /*
+/*
  *              By license terms the following line of code must not be modified.
  */
                 websWrite(wp, T("Server: %s\r\n"), WEBS_NAME);
 /*
+/*
  *              Timestamp/Date is usually the next to go
  */
 …
                 if (code == 401) {
                         if (!(wp->flags & WEBS_AUTH_DIGEST)) {
                                 websWrite(wp, T("WWW-Authenticate: Basic realm=\"%s\"\r\n"),
+                                websWrite(wp, T("WWW-Authenticate: Basic realm=\"%s\"\r\n"),
                                         websGetRealm());
 #ifdef DIGEST_ACCESS_SUPPORT
 …
             /* $$$ before... (note commas instead of semicolons...)
                                 nonce = websCalcNonce(wp),
                                 opaque = websCalcOpaque(wp),
+                                nonce = websCalcNonce(wp),
+                                opaque = websCalcOpaque(wp),
             $$$ after */
                                 nonce = websCalcNonce(wp);
                                 opaque = websCalcOpaque(wp);
+                                opaque = websCalcOpaque(wp);
             /* ...$$$ end */
                                 websWrite(wp,
+                                websWrite(wp,
                                         T("WWW-Authenticate: Digest realm=\"%s\", domain=\"%s\",")
                                         T("qop=\"%s\", nonce=\"%s\", opaque=\"%s\",")
                                         T("algorithm=\"%s\", stale=\"%s\"\r\n"),
+                                        T("algorithm=\"%s\", stale=\"%s\"\r\n"),
                                         websGetRealm(),
                                         websGetHostUrl(),
 …
                 websWrite(wp, T("Content-Type: text/html\r\n"));
 /*
  *              We don't do a string length here as the message may be multi-line.
  *              Ie. <CR><LF> will count as only one and we will have a content-length
+ *              We don't do a string length here as the message may be multi-line.
+ *              Ie. <CR><LF> will count as only one and we will have a content-length
  *              that is too short.
+ *
 …
  *      Add human readable message for completeness. Should not be required.
  */
         fmtAlloc(&msgbuf, WEBS_MAX_URL + 80,
+        fmtAlloc(&msgbuf, WEBS_MAX_URL + 80,
                 T("<html><head></head><body>\r\n\
                 This document has moved to a new <a href=\"%s\">location</a>.\r\n\
 …
 /******************************************************************************/
 /*
+/*
  *      Output an error message and cleanup
  */
 …
    if (!reEntry)
+   {
       /*
+      /*
        * The dmfRichError function that we're about to call may very well call
        * websError() as part of its work. If that happens, we do NOT want to
 …
  */
         buf = NULL;
         fmtAlloc(&buf, WEBS_BUFSIZE, msg, websErrorMsg(code),
+        fmtAlloc(&buf, WEBS_BUFSIZE, msg, websErrorMsg(code),
                 websErrorMsg(code), wp->url, userMsg);
 …
         char_t          *buf;
         int                      rc;
         a_assert(websValid(wp));
 …
                 trace(0, T("webs: websWrite lost data, buffer overflow\n"));
+        }
         va_end(vargs);
         a_assert(buf);
 …
 /*
  *      Write a block of data of length "nChars" to the user's browser. Public
  *      write block procedure.  If unicode is turned on this function expects
+ *      write block procedure.  If unicode is turned on this function expects
  *      buf to be a unicode string and it converts it to ASCII before writing.
  *      See websWriteDataNonBlock to always write binary or ASCII data with no
+ *      See websWriteDataNonBlock to always write binary or ASCII data with no
  *      unicode conversion.  This returns the number of char_t's processed.
  *      It spins until nChars are flushed to the socket.  For non-blocking
 …
         pBuf = asciiBuf = ballocUniToAsc(buf, nChars);
         while (nChars > 0) {
+        while (nChars > 0) {
 #ifdef WEBS_SSL_SUPPORT
                 if (wp->flags & WEBS_SECURE) {
 …
         char_t  *ip,  *op;
         int             num, i, c;
         a_assert(decoded);
         a_assert(token);
 …
       *newLine = '\0';
+   }
    fmtAlloc(&buf, WEBS_MAX_URL + 80, T("%s\t%s\t%s\tcode = %d\n"),
+   fmtAlloc(&buf, WEBS_MAX_URL + 80, T("%s\t%s\t%s\tcode = %d\n"),
       timeStr, wp->ipaddr, wp->url, code);
 #else
         fmtAlloc(&buf, WEBS_MAX_URL + 80, T("%d %s %d %d\n"), time(0),
+        fmtAlloc(&buf, WEBS_MAX_URL + 80, T("%d %s %d %d\n"), time(0),
                 wp->url, code, wp->written);
 #endif
 …
 /*
  *      If using Keep Alive (HTTP/1.1) we keep the socket open for a period
  *      while waiting for another request on the socket.
+ *      while waiting for another request on the socket.
  */
         if (wp->flags & WEBS_KEEP_ALIVE) {
 …
                                 ringqFlush(&wp->header);
+                        }
                         socketCreateHandler(wp->sid, SOCKET_READABLE, websSocketEvent,
+                        socketCreateHandler(wp->sid, SOCKET_READABLE, websSocketEvent,
                                 (int) wp);
                         websTimeoutCancel(wp);
 …
         a_assert(websValid(wp));
         if (dir) {
+        if (dir) {
                 tmp = wp->dir;
                 wp->dir = bstrdup(B_L, dir);
 …
 #ifdef WEBS_IF_MODIFIED_SUPPORT
 /******************************************************************************/
 /*
  *      These functions are intended to closely mirror the syntax for HTTP-date
+/*
+ *      These functions are intended to closely mirror the syntax for HTTP-date
  *      from RFC 2616 (HTTP/1.1 spec).  This code was submitted by Pete Bergstrom.
  */
 /*
+/*
  *      RFC1123Date     = wkday "," SP date1 SP time SP "GMT"
  *      RFC850Date      = weekday "," SP date2 SP time SP "GMT"
  *      ASCTimeDate     = wkday SP date3 SP time SP 4DIGIT
+ *
  *      Each of these functions tries to parse the value and update the index to
+ *      Each of these functions tries to parse the value and update the index to
  *      the point it leaves off parsing.
  */
 …
 /******************************************************************************/
 /*
+/*
  *      Parse an N-digit value
  */
 static int parseNDIGIT(char_t *buf, int digits, int *index)
+static int parseNDIGIT(char_t *buf, int digits, int *index)
+{
         int tmpIndex, returnValue;
 …
+        }
         *index = tmpIndex;
         return returnValue;
+}
 …
  */
 static int parseMonth(char_t *buf, int *index)
+{
 /*
  *      "Jan" | "Feb" | "Mar" | "Apr" | "May" | "Jun" |
+static int parseMonth(char_t *buf, int *index)
+{
+/*
+ *      "Jan" | "Feb" | "Mar" | "Apr" | "May" | "Jun" |
  *      "Jul" | "Aug" | "Sep" | "Oct" | "Nov" | "Dec"
  */
 …
 /******************************************************************************/
 /*
+/*
  *      Parse a year value (either 2 or 4 digits)
  */
 static int parseYear(char_t *buf, int *index)
+static int parseYear(char_t *buf, int *index)
+{
         int tmpIndex, returnValue;
 …
                 if (returnValue >= 0) {
 /*
  *                      Assume that any year earlier than the start of the
+ *                      Assume that any year earlier than the start of the
  *                      epoch for time_t (1970) specifies 20xx
  */
 …
 /******************************************************************************/
 /*
  *      The formulas used to build these functions are from "Calendrical Calculations",
+/*
+ *      The formulas used to build these functions are from "Calendrical Calculations",
  *      by Nachum Dershowitz, Edward M. Reingold, Cambridge University Press, 1997.
  */
 …
  */
 int GregorianLeapYearP(long year)
+int GregorianLeapYearP(long year)
+{
         int             result;
         long    tmp;
         tmp = year % 400;
 …
  */
 long FixedFromGregorian(long month, long day, long year)
+long FixedFromGregorian(long month, long day, long year)
+{
         long fixedDate;
         fixedDate = (long)(GregorianEpoch - 1 + 365 * (year - 1) +
+        fixedDate = (long)(GregorianEpoch - 1 + 365 * (year - 1) +
                 floor((year - 1) / 4.0) -
                 floor((double)(year - 1) / 100.0) +
                 floor((double)(year - 1) / 400.0) +
+                floor((double)(year - 1) / 100.0) +
+                floor((double)(year - 1) / 400.0) +
                 floor((367.0 * ((double)month) - 362.0) / 12.0));
 …
  */
 long GregorianYearFromFixed(long fixedDate)
+long GregorianYearFromFixed(long fixedDate)
+{
         long result, d0, n400, d1, n100, d2, n4, d3, n1, d4, year;
 …
 /******************************************************************************/
 /*
+/*
  *      Returns the Gregorian date from a fixed date
  *      (not needed for this use, but included for completeness
 …
 #if 0
 GregorianFromFixed(long fixedDate, long *month, long *day, long *year)
+GregorianFromFixed(long fixedDate, long *month, long *day, long *year)
+{
         long priorDays, correction;
 …
 /******************************************************************************/
 /*
+/*
  *      Returns the difference between two Gregorian dates
  */
 long GregorianDateDifference(   long month1, long day1, long year1,
                                                                 long month2, long day2, long year2)
+{
         return FixedFromGregorian(month2, day2, year2) -
+                                                                long month2, long day2, long year2)
+{
+        return FixedFromGregorian(month2, day2, year2) -
                 FixedFromGregorian(month1, day1, year1);
+}
 …
 #define SECONDS_PER_DAY 24*60*60
 static int parseTime(char_t *buf, int *index)
+{
 /*
+static int parseTime(char_t *buf, int *index)
+{
+/*
  *      Format of buf is - 2DIGIT ":" 2DIGIT ":" 2DIGIT
  */
 …
  */
 static time_t dateToTimet(int year, int month, int day)
+static time_t dateToTimet(int year, int month, int day)
+{
         long dayDifference;
      /*
       * Bug fix by Jeff Reeder (Jun 14, 2002): The 'month' parameter is
       * numbered from  0 (Jan == 0), but FixedFromGregorian() takes
       * months numbered from 1 (January == 1). We need to add 1
       * to the month
+     /*
+      * Bug fix by Jeff Reeder (Jun 14, 2002): The 'month' parameter is
+      * numbered from  0 (Jan == 0), but FixedFromGregorian() takes
+      * months numbered from 1 (January == 1). We need to add 1
+      * to the month
       */
         dayDifference = FixedFromGregorian(month + 1, day, year) -
+        dayDifference = FixedFromGregorian(month + 1, day, year) -
                 FixedFromGregorian(1, 1, 1970);
 …
  */
 static time_t parseDate1or2(char_t *buf, int *index)
+{
 /*
+static time_t parseDate1or2(char_t *buf, int *index)
+{
+/*
  *      Format of buf is either
  *      2DIGIT SP month SP 4DIGIT
 …
         if (buf[tmpIndex] == T(',')) {
 /*
  *              Skip over the ", "
  */
                 tmpIndex += 2;
+/*
+ *              Skip over the ", "
+ */
+                tmpIndex += 2;
                 dayValue = parseNDIGIT(buf, 2, &tmpIndex);
 …
  *                      Skip over the space or hyphen
  */
                         tmpIndex++;
+                        tmpIndex++;
                         monthValue = parseMonth(buf, &tmpIndex);
                         if (monthValue >= 0) {
 …
  *                              Skip over the space or hyphen
  */
                                 tmpIndex++;
+                                tmpIndex++;
                                 yearValue = parseYear(buf, &tmpIndex);
+                        }
 …
                         (yearValue >= 0)) {
                         if (yearValue < 1970) {
 /*
  *                              Allow for Microsoft IE's year 1601 dates
  */
                                 returnValue = 0;
+/*
+ *                              Allow for Microsoft IE's year 1601 dates
+ */
+                                returnValue = 0;
                         } else {
                                 returnValue = dateToTimet(yearValue, monthValue, dayValue);
 …
+                }
+        }
         return returnValue;
+}
 …
  */
 static time_t parseDate3Time(char_t *buf, int *index)
+static time_t parseDate3Time(char_t *buf, int *index)
+{
 /*
 …
         monthValue = parseMonth(buf, &tmpIndex);
         if (monthValue >= 0) {
 /*
  *              Skip over the space
  */
                 tmpIndex++;
+/*
+ *              Skip over the space
+ */
+                tmpIndex++;
                 if (buf[tmpIndex] == T(' ')) {
 /*
  *                      Skip over this space too
  */
                         tmpIndex++;
+ *                      Skip over this space too
+ */
+                        tmpIndex++;
                         dayValue = parseNDIGIT(buf, 1, &tmpIndex);
                 } else {
                         dayValue = parseNDIGIT(buf, 2, &tmpIndex);
+                }
 /*
+/*
  *              Now get the time and time SP 4DIGIT
  */
                 timeValue = parseTime(buf, &tmpIndex);
                 if (timeValue >= 0) {
 /*
+/*
  *                      Now grab the 4DIGIT year value
  */
 …
                 *index = tmpIndex;
+        }
         return returnValue;
+}
 …
  *      Although this looks like a trivial function, I found I was replicating the implementation
  *      seven times in the parseWeekday function. In the interests of minimizing code size
  *      and redundancy, it is broken out into a separate function. The cost of an extra
+ *      and redundancy, it is broken out into a separate function. The cost of an extra
  *      function call I can live with given that it should only be called once per HTTP request.
  */
 static int bufferIndexIncrementGivenNTest(char_t *buf, int testIndex, char_t testChar,
                                                                                   int foundIncrement, int notfoundIncrement)
+static int bufferIndexIncrementGivenNTest(char_t *buf, int testIndex, char_t testChar,
+                                                                                  int foundIncrement, int notfoundIncrement)
+{
         if (buf[testIndex] == testChar) {
 …
  */
 static int parseWeekday(char_t *buf, int *index)
+{
 /*
+static int parseWeekday(char_t *buf, int *index)
+{
+/*
  *      Format of buf is either
  *      "Mon" | "Tue" | "Wed" | "Thu" | "Fri" | "Sat" | "Sun"
 …
                         timeValue = parseTime(cmd, &index);
                         if (timeValue >= 0) {
 /*
+/*
  *                              Now match up that "GMT" string for completeness
  *                              Compute the final value if there were no problems in the parse
 …
+                        }
                 } else {
 /*
+/*
  *                      Try the other form - wkday SP date3 SP time SP 4DIGIT
  */

cpukit/httpd/webs.h

-                      r0893220
+                      r0a7278e
 /*
+/*
  *      webs.h -- GoAhead Web public header
+ *
 …
 /******************************** Description *********************************/
 /*
+/*
  *      GoAhead Web Server header. This defines the Web public APIs.
  *      Include this header for files that contain ASP or Form procedures.
 …
 #define CGI_BIN                                 T("cgi-bin")
 /*
+/*
  *      Request flags. Also returned by websGetRequestFlags().
  */
 #define WEBS_LOCAL_PAGE                 0x1                     /* Request for local webs page */
+#define WEBS_LOCAL_PAGE                 0x1                     /* Request for local webs page */
 #define WEBS_KEEP_ALIVE                 0x2                     /* HTTP/1.1 keep alive */
 #define WEBS_DONT_USE_CACHE             0x4                     /* Not implemented cache support */
 …
 #define WEBS_POST_REQUEST               0x20            /* Post request operation */
 #define WEBS_LOCAL_REQUEST              0x40            /* Request from this system */
 #define WEBS_HOME_PAGE                  0x80            /* Request for the home page */
 #define WEBS_ASP                                0x100           /* ASP request */
+#define WEBS_HOME_PAGE                  0x80            /* Request for the home page */
+#define WEBS_ASP                                0x100           /* ASP request */
 #define WEBS_HEAD_REQUEST               0x200           /* Head request */
 #define WEBS_CLEN                               0x400           /* Request had a content length */
 …
 #define WEBS_HANDLER_LAST       0x2                     /* Process this handler last */
 /*
+/*
  *      Per socket connection webs structure
  */
 …
 /******************************** Prototypes **********************************/
 extern int               websAccept(int sid, char *ipaddr, int port, int listenSid);
 extern int               websAspDefine(char_t *name,
+extern int               websAspDefine(char_t *name,
                                         int (*fn)(int ejid, webs_t wp, int argc, char_t **argv));
 extern int               websAspRequest(webs_t wp, char_t *lpath);
 …
 extern char_t   *websErrorMsg(int code);
 extern void      websFooter(webs_t wp);
 extern int               websFormDefine(char_t *name, void (*fn)(webs_t wp,
+extern int               websFormDefine(char_t *name, void (*fn)(webs_t wp,
                                         char_t *path, char_t *query));
 extern char_t   *websGetDefaultDir(void);
 …
 extern void              websRedirect(webs_t wp, char_t *url);
 extern void      websSecurityDelete(void);
 extern int               websSecurityHandler(webs_t wp, char_t *urlPrefix,
                                         char_t *webDir, int arg, char_t *url, char_t *path,
+extern int               websSecurityHandler(webs_t wp, char_t *urlPrefix,
+                                        char_t *webDir, int arg, char_t *url, char_t *path,
                                         char_t *query);
 extern void      websSetDefaultDir(char_t *dir);
 …
 extern int               websTestVar(webs_t wp, char_t *var);
 extern void              websTimeoutCancel(webs_t wp);
 extern int               websUrlHandlerDefine(char_t *urlPrefix, char_t *webDir,
                                         int arg, int (*fn)(webs_t wp, char_t *urlPrefix,
                                         char_t *webDir, int arg, char_t *url, char_t *path,
+extern int               websUrlHandlerDefine(char_t *urlPrefix, char_t *webDir,
+                                        int arg, int (*fn)(webs_t wp, char_t *urlPrefix,
+                                        char_t *webDir, int arg, char_t *url, char_t *path,
                                         char_t *query), int flags);
 extern int               websUrlHandlerDelete(int (*fn)(webs_t wp, char_t *urlPrefix,
                                         char_t *webDir, int arg, char_t *url, char_t *path,
+                                        char_t *webDir, int arg, char_t *url, char_t *path,
                                         char_t *query));
 extern int               websUrlHandlerRequest(webs_t wp);
 extern int               websUrlParse(char_t *url, char_t **buf, char_t **host,
                                         char_t **path, char_t **port, char_t **query,
+extern int               websUrlParse(char_t *url, char_t **buf, char_t **host,
+                                        char_t **path, char_t **port, char_t **query,
                                         char_t **proto, char_t **tag, char_t **ext);
 extern char_t   *websUrlType(char_t *webs, char_t *buf, int charCnt);
 …
 /*
  *      Prototypes for functions available when running as part of the
+ *      Prototypes for functions available when running as part of the
  *      GoAhead Embedded Management Framework (EMF)
  */

cpukit/httpd/websSSL.c

-                      r0893220
+                      r0a7278e
 /*************************** Forward Declarations *****************************/
 static int              websSSLSetCertStuff(SSL_CTX *ctx,
                                                                         char *cert_file,
+static int              websSSLSetCertStuff(SSL_CTX *ctx,
+                                                                        char *cert_file,
                                                                         char *key_file);
 static int              websSSLVerifyCallback(int ok, X509_STORE_CTX *ctx);
 …
         char            *certFile, *keyFile, *CApath, *CAfile;
         SSL_METHOD      *meth;
 /*
  *      Install and initialize the SSL library
  */
         apps_startup();
         trace(7, T("SSL: Initializing SSL\n"));
+        trace(7, T("SSL: Initializing SSL\n"));
 #ifdef SSLC
 …
         if (sslctx == NULL) {
                 trace(2, T("SSL: Unable to create SSL context!\n"));
+                trace(2, T("SSL: Unable to create SSL context!\n"));
                 return -1;
+        }
 …
         if ((!SSL_CTX_load_verify_locations(sslctx, CAfile, CApath)) ||
                 (!SSL_CTX_set_default_verify_paths(sslctx))) {
                 trace(2, T("SSL: Unable to set cert verification locations!\n"));
+                trace(2, T("SSL: Unable to set cert verification locations!\n"));
                 websSSLClose();
                 return -1;
 …
  *      Open the socket
  */
         sslListenSock = socketOpenConnection(NULL, SSL_PORT,
+        sslListenSock = socketOpenConnection(NULL, SSL_PORT,
                 websSSLAccept, SOCKET_BLOCK);
         if (sslListenSock < 0) {
                 trace(2, T("SSL: Unable to open SSL socket on port <%d>!\n"),
+                trace(2, T("SSL: Unable to open SSL socket on port <%d>!\n"),
                         SSL_PORT);
                 return -1;
 …
 void websSSLClose()
+{
         trace(7, T("SSL: Closing SSL\n"));
+        trace(7, T("SSL: Closing SSL\n"));
         if (sslctx != NULL) {
 …
  *      to know for permitting administrative operations only for local access
  */
         if (gstrcmp(wp->ipaddr, T("127.0.0.1")) == 0 ||
                         gstrcmp(wp->ipaddr, websIpaddr) == 0 ||
+        if (gstrcmp(wp->ipaddr, T("127.0.0.1")) == 0 ||
+                        gstrcmp(wp->ipaddr, websIpaddr) == 0 ||
                         gstrcmp(wp->ipaddr, websHost) == 0) {
                 wp->flags |= WEBS_LOCAL_REQUEST;
 …
         if (mask & SOCKET_READABLE) {
                 websSSLReadEvent(wp);
+        }
+        }
         if (mask & SOCKET_WRITABLE) {
                 if (wp->writeSocket) {
                         (*wp->writeSocket)(wp);
+                }
+        }
+        }
+}
 …
         if (certFile != NULL) {
                 if (SSL_CTX_use_certificate_file(ctx, certFile,
+                if (SSL_CTX_use_certificate_file(ctx, certFile,
                         SSL_FILETYPE_PEM) <= 0) {
                         trace(2, T("SSL: Unable to set certificate file <%s>\n"),
                                 certFile);
+                                certFile);
                         return -1;
+                }
 …
                 if (SSL_CTX_use_PrivateKey_file(ctx, keyFile, SSL_FILETYPE_PEM) <= 0) {
                         trace(2, T("SSL: Unable to set private key file <%s>\n"),
                                 keyFile);
+                                keyFile);
                         return -1;
+                }
 /*
+/*
  *              Now we know that a key and cert have been set against
  *              the SSL context
+ *              the SSL context
  */
                 if (!SSL_CTX_check_private_key(ctx)) {
                         trace(2, T("SSL: Check of private key file <%s> FAILED!\n"),
                                 keyFile);
+                                keyFile);
                         return -1;
+                }
 …
+        }
         if (SSL_CTX_use_certificate_file(sslctx, certFile,
+        if (SSL_CTX_use_certificate_file(sslctx, certFile,
                 SSL_FILETYPE_PEM) <= 0) {
                 return -1;
+        }
 /*
+/*
  *      Confirm that the certificate and the private key jive.
  */
 …
                 return -1;
+        }
 /*
+/*
  *      Confirm that the certificate and the private key jive.
  */
 …
 /******************************************************************************/
 /*
  *      Free SSL resources
+ *      Free SSL resources
  */
 …
+        }
 /*
+/*
  *      Make sure we re-use sessions
  */
 …
         if ((wsp == NULL) || (wsp->bio == NULL)) {
                 return -1;
+        }
+        }
         return BIO_eof(wsp->bio);
 …
         if ((wsp == NULL) || (wsp->bio == NULL)) {
                 return -1;
+        }
+        }
         return BIO_read(wsp->bio, buf, len);
 …
         if ((wsp == NULL) || (wsp->bio == NULL)) {
                 return -1;
+        }
+        }
         while (1) {
 …
                         return rc;
+                }
                 if (rc == 0) {
 /*
 …
                 } else if (c == '\r') {
                         continue;
+                }
+                }
 /*
  *              Append character to buf
 …
         if ((wsp == NULL) || (wsp->bio == NULL)) {
                 return -1;
+        }
+        }
         return BIO_write(wsp->bio, buf, len);
 …
         if ((wsp == NULL) || (wsp->bio == NULL)) {
                 return -1;
+        }
+        }
         return BIO_flush(wsp->bio);

cpukit/httpd/websSSL.h

-                      r0893220
+                      r0a7278e
 /*
+/*
  *      websSSL.h -- SSL Patch header
+ *
 …
 /******************************** Description *********************************/
 /*
  *      Header file for the GoAhead Patch for SSL. This defines the interface to
+/*
+ *      Header file for the GoAhead Patch for SSL. This defines the interface to
  *      integrate SSL into the GoAhead Webserver.
  */

cpukit/httpd/websda.c

-                      r0893220
+                      r0a7278e
 /*****************************************************************************/
 /*
  *      Convenience call to websMD5binary
+ *      Convenience call to websMD5binary
  *      (Performs char_t to char conversion and back)
  */
 …
 /******************************************************************************/
 /*
  *      Get a Nonce value for passing along to the client.  This function
  *      composes the string "RANDOMKEY:timestamp:myrealm" and
  *      calculates the MD5 digest placing it in output.
+ *      Get a Nonce value for passing along to the client.  This function
+ *      composes the string "RANDOMKEY:timestamp:myrealm" and
+ *      calculates the MD5 digest placing it in output.
  */
 …
 #ifdef DIGEST_ACCESS_SUPPORT
         fmtAlloc(&prenonce, 256, T("%s:%s:%s"), RANDOMKEY, gasctime(newtime),
                 wp->realm);
+                wp->realm);
 #else
         fmtAlloc(&prenonce, 256, T("%s:%s:%s"), RANDOMKEY, gasctime(newtime),
                 RANDOMKEY);
+        fmtAlloc(&prenonce, 256, T("%s:%s:%s"), RANDOMKEY, gasctime(newtime),
+                RANDOMKEY);
 #endif
         a_assert(prenonce);
 …
                 fmtAlloc(&preDigest, 255, T("%s:%s:%s"), a1prime, wp->nonce, a2prime);
         } else {
                 fmtAlloc(&preDigest, 255, T("%s:%s:%s:%s:%s:%s"),
                         a1prime,
+                fmtAlloc(&preDigest, 255, T("%s:%s:%s:%s:%s:%s"),
+                        a1prime,
                         wp->nonce,
                         wp->nc,

cpukit/httpd/websda.h

-                      r0893220
+                      r0a7278e
 /*
+/*
  *      websda.h -- GoAhead Digest Access Authentication public header
+ *
 …
 /******************************** Description *********************************/
 /*
  *      GoAhead Digest Access Authentication header. This defines the Digest
  *      access authentication public APIs.  Include this header for files that
+/*
+ *      GoAhead Digest Access Authentication header. This defines the Digest
+ *      access authentication public APIs.  Include this header for files that
  *      use DAA functions
  */

cpukit/httpd/websuemf.c

-                      r0893220
+                      r0a7278e
         sched_t *s;
         if (sched == NULL || schedid == -1 || schedid >= schedMax ||
+        if (sched == NULL || schedid == -1 || schedid >= schedMax ||
                 (s = sched[schedid]) == NULL) {
                 return;
 …
         sched_t *s;
         if (sched == NULL || schedid == -1 || schedid >= schedMax ||
+        if (sched == NULL || schedid == -1 || schedid >= schedMax ||
                 (s = sched[schedid]) == NULL) {
                 return;
 …
         sched_t         *s;
         int                     schedid;
         static int      next = 0;
+        static int      next = 0;
 /*
 …
                 if (schedid == next) {
 /*
  *                      We've gone all the way through the queue without finding
+ *                      We've gone all the way through the queue without finding
  *                      anything to do so just return.
  */

cpukit/httpd/wsIntrn.h

-                      r0893220
+                      r0a7278e
 /*
+/*
  *      wsIntrn.h -- Internal GoAhead Web server header
+ *
 …
  * $Id$
  */
 #ifndef _h_WEBS_INTERNAL
 #define _h_WEBS_INTERNAL 1
 …
 /******************************** Description *********************************/
 /*
+/*
  *      Internal GoAhead Web Server header. This defines the Web private APIs
  *      Include this header when you want to create URL handlers.
 …
 /*
  *      Define this to enable logging of web accesses to a file
+ *      Define this to enable logging of web accesses to a file
  *              #define WEBS_LOG_SUPPORT 1
+ *
 …
 /********************************** Defines ***********************************/
 /*
+/*
  *      Read handler flags and state
  */
 …
  *      URL handler structure. Stores the leading URL path and the handler
  *      function to call when the URL path is seen.
  */
 typedef struct {
         int             (*handler)(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
                         char_t *url, char_t *path,
+ */
+typedef struct {
+        int             (*handler)(webs_t wp, char_t *urlPrefix, char_t *webDir, int arg,
+                        char_t *url, char_t *path,
                         char_t *query);                                 /* Callback URL handler function */
         char_t  *webDir;                                                /* Web directory if required */
 …
 } websUrlHandlerType;
 /*
+/*
  *      Webs statistics
  */
 …
 extern websStatsType websStats;                         /* Web access stats */
 /*
+/*
  *      Error code list
  */
 …
 } websErrorType;
 /*
+/*
  *      Mime type list
  */
 …
 extern int               websAspWrite(int ejid, webs_t wp, int argc, char_t **argv);
 extern void      websDefaultClose(void);
 extern int               websDefaultHandler(webs_t wp, char_t *urlPrefix,
                                         char_t *webDir, int arg, char_t *url, char_t *path,
+extern int               websDefaultHandler(webs_t wp, char_t *urlPrefix,
+                                        char_t *webDir, int arg, char_t *url, char_t *path,
                                         char_t *query);
 extern int               websFormHandler(webs_t wp, char_t *urlPrefix, char_t *webDir,
 …
                                         char_t **envp, char_t *stdIn, char_t *stdOut);
 extern int               websOpen(int sid);
 extern void      websResponse(webs_t wp, int code, char_t *msg,
+extern void      websResponse(webs_t wp, int code, char_t *msg,
                                         char_t *redirect);
 extern int               websJavaScriptEval(webs_t wp, char_t *script);
 …
 extern int               websRomPageStat(char_t *path, websStatType *sbuf);
 extern long              websRomPageSeek(webs_t wp, long offset, int origin);
 extern void      websSetRequestSocketHandler(webs_t wp, int mask,
+extern void      websSetRequestSocketHandler(webs_t wp, int mask,
                                         void (*fn)(webs_t wp));
 extern int               websSolutionHandler(webs_t wp, char_t *urlPrefix,
                                         char_t *webDir, int arg, char_t *url, char_t *path,
+                                        char_t *webDir, int arg, char_t *url, char_t *path,
                                         char_t *query);
 extern void      websUrlHandlerClose(void);
 …
 /*
  *      Prototypes for functions available when running as part of the
+ *      Prototypes for functions available when running as part of the
  *      GoAhead Embedded Management Framework (EMF)
  */

cpukit/libfs/src/devfs/devfs.h

-                      r0893220
+                      r0a7278e
 /**
+/**
 *  @file  libfs/devfs/devfs.h
+*
 …
  */
 typedef struct
+typedef struct
+{
   /** This member points to device name which is a null-terminated string */
 …
 /**
  *  The following defines the device table size. This values
  *  is configured during application configuration time by
+ *  is configured during application configuration time by
  *  the user. The default value is set to 4.
  */
 …
  */
 extern rtems_filesystem_operations_table devFS_ops;
+extern rtems_filesystem_operations_table devFS_ops;
 /**
 …
  */
 extern rtems_filesystem_file_handlers_r  devFS_file_handlers;
+extern rtems_filesystem_file_handlers_r  devFS_file_handlers;
 …
  *  This handler maps open operation to rtems_io_open.
  *  @param iop This is the RTEMS's internal representation of file.
  *  @param pathname a null-terminated string that starts with /dev.
+ *  @param pathname a null-terminated string that starts with /dev.
  *  @param flag access flags
  *  @param mode access mode
 …
 /**
  *  This routine is invoked upon determination of a node type.
  *  Since this is a device-only filesystem, so there is only
+ *  Since this is a device-only filesystem, so there is only
  *  one node type in the system.
+ *
  *  @param pathloc contains filesytem access information, this
+ *
+ *  @param pathloc contains filesytem access information, this
  *         parameter is ignored
  *  @retval always returns RTEMS_FILESYSTEM_DEVICE
 …
 /**
  *  This routine is invoked to determine if 'pathname' exists.
  *  This routine first check access flags, then it searches
+ *  This routine first check access flags, then it searches
  *  the device table to get the information.
+ *
+ *
  *  @param pathname device name to be searched
  *  @param flags access flags
  *  @param pathloc contains filesystem access information
  *  @retval upon success(pathname exists), this routines
  *  returns 0; if 'flag' is invalid, it returns -1 and errno
+ *  @retval upon success(pathname exists), this routines
+ *  returns 0; if 'flag' is invalid, it returns -1 and errno
  *  is set to EIO; otherwise, it returns -1 and errno is set to ENOENT
  */
 …
 /**
  *  This routine is given a path to evaluate and a valid start
+ *  This routine is given a path to evaluate and a valid start
  *  location. It is responsible for finding the parent node for
  *  a requested make command, setting pathloc information to
  *  identify the parent node, and setting the name pointer to
  *  the first character of the name of the new node. In device
+ *  identify the parent node, and setting the name pointer to
+ *  the first character of the name of the new node. In device
  *  only filesystem, devices do not has a tree hierarchy, there
  *  are no parent-child relationship. So this routine is rather
+ *  are no parent-child relationship. So this routine is rather
  *  simple, it just set *name to path and returns
+ *
  *  @param path device path to be evaluated
  *  @param pathloc contains filesystem access information, this
+ *  @param pathloc contains filesystem access information, this
  *         parameter is ignored
  *  @param name
+ *  @param name
  *  @retval always returns 0
  */
 …
 /**
  *  This routine is invoked upon registration of a new device
  *  file. It is responsible for creating a item in the main
  *  device table. This routine searches the device table in
  *  sequential order, when found a empty slot, it fills the slot
+ *  file. It is responsible for creating a item in the main
+ *  device table. This routine searches the device table in
+ *  sequential order, when found a empty slot, it fills the slot
  *  with proper values.
+ *
 …
  *  @retval upon success, this routine returns 0; if 'path'
  *  already exist, it returns -1 and errno is set to EEXIST;
  *  if device table is full, it returns -1 and errno is set
+ *  if device table is full, it returns -1 and errno is set
  *  to ENOMEM
  */
 …
 extern int devFS_mknod(
    const char                        *path,
    mode_t                             mode,
    dev_t                              dev,
    rtems_filesystem_location_info_t  *pathloc
+   mode_t                             mode,
+   dev_t                              dev,
+   rtems_filesystem_location_info_t  *pathloc
 );
 …
  *  initializing it to a known state, and set device file operation
  *  handlers. After this, the device-only filesytem is ready for use
+ *
+ *
  *  @param  temp_mt_entry
  *  @retval upon success, this routine returns 0; otherwise it returns
  *  -1 and errno is set to proper value. The only error is when malloc
+ *  -1 and errno is set to proper value. The only error is when malloc
  *  failed, and errno is set to NOMEM.
  */
 …
  *  prints out their detail information. For example, on one system,
  *  devFS_show will print out following message:
+ *
+ *
  *  /dev/console     0  0
  *  /dev/clock       1  0
  *  /dev/tty0        0  0
  *  /flash           2  0
+ *
  *  This routine is intended for debugging, and can be used by shell
+ *
+ *  This routine is intended for debugging, and can be used by shell
  *  program to provide user with the system information.
+ *
+ *
  *  @param  none
  *  @retval 0

cpukit/libfs/src/devfs/devfs_init.c

-                      r0893220
+                      r0a7278e
 #include "devfs.h"
 rtems_filesystem_operations_table devFS_ops =
+rtems_filesystem_operations_table devFS_ops =
+{
     devFS_evaluate_path,
 …
 rtems_filesystem_file_handlers_r devFS_file_handlers =
+rtems_filesystem_file_handlers_r devFS_file_handlers =
+{
     devFS_open,
 …
   memset(
     device_name_table, 0,
+    device_name_table, 0,
     sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
     );

cpukit/libfs/src/devfs/devfs_mknod.c

-                      r0893220
+                      r0a7278e
 int devFS_mknod(
   const char                        *path,
   mode_t                             mode,
   dev_t                              dev,
   rtems_filesystem_location_info_t  *pathloc
+  mode_t                             mode,
+  dev_t                              dev,
+  rtems_filesystem_location_info_t  *pathloc
+)
+{
 …
   /*
    * This is a special case. In rtems_filesystem_initialize,
    * a special device '/dev' will be created. We check this
    * condition and do not create the '/dev' and the 'path'
+   * This is a special case. In rtems_filesystem_initialize,
+   * a special device '/dev' will be created. We check this
+   * condition and do not create the '/dev' and the 'path'
    * actually passed in is 'dev', not '/dev'. Just return 0 to
    * indicate we are OK.
    */
   if ((path[0] == 'd') && (path[1] == 'e') &&
+  if ((path[0] == 'd') && (path[1] == 'e') &&
       (path[2] == 'v') && (path[3] == '\0'))
       return 0;

cpukit/libfs/src/devfs/devfs_node_type.c

r0893220	r0a7278e
18	18	{
19	19	/*
20		* There is only one type of node: device
	20	* There is only one type of node: device
21	21	*/
22	22

cpukit/libfs/src/devfs/devfs_show.c

r0893220	r0a7278e
27	27	for (i = 0; i < rtems_device_table_size; i++){
28	28	if (device_name_table[i].device_name){
29		printk("/%s %d %d\n", device_name_table[i].device_name,
	29	printk("/%s %d %d\n", device_name_table[i].device_name,
30	30	device_name_table[i].major, device_name_table[i].minor);
31	31	}

cpukit/libfs/src/dosfs/dosfs.h

-                      r0893220
+                      r0a7278e
  *  Application interface to MSDOS filesystem.
  */
 /*
  *  Copyright (C) 2001 OKTET Ltd., St.-Petersburg, Russia
 …
  *  @(#) $Id$
  */
 #ifndef _RTEMS_DOSFS_H
 #define _RTEMS_DOSFS_H

cpukit/libfs/src/dosfs/fat.c

-                      r0893220
+                      r0a7278e
     return fat_buf_release(fs_info);
+}
 /* fat_cluster_read --
  *     wrapper for reading a whole cluster at once
 …
     /* Evaluate boot record */
     vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
     if ( (vol->bps != 512)  &&
          (vol->bps != 1024) &&
+    if ( (vol->bps != 512)  &&
+         (vol->bps != 1024) &&
          (vol->bps != 2048) &&
          (vol->bps != 4096))
 …
     vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
     /* calculate the count of sectors occupied by the root directory */
     vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
 …
     else
         vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
     vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
+    vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
                      vol->rdir_secs;
     /* for  FAT12/16 root dir starts at(sector) */
     vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
     if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
         vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
     else
         vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
     data_secs = vol->tot_secs - vol->data_fsec;
 …
+    {
         vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
         vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
         if (vol->mirror)
 …
                 rtems_disk_release(vol->dd);
                 return -1;
+            }
             if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
+            }
+            if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
                 FAT_FSINFO_LEAD_SIGNATURE_VALUE)
+            {
 …
                     rtems_disk_release(vol->dd);
                     return -1;
+                }
+                }
                 vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
                 vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
                 rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
+                rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
 xFFFFFFFF);
                 if ( rc != RC_OK )

cpukit/libfs/src/dosfs/fat.h

-                      r0893220
+                      r0a7278e
 #    define CT_LE_W(v) CPU_swap_u16((uint16_t)(v))
 #    define CT_LE_L(v) CPU_swap_u32((uint32_t)(v))
 #else
+#else
 #    define CF_LE_W(v) (v)
 #    define CF_LE_L(v) (v)
 …
 #define FAT_GET_ADDR(x, ofs)       ((uint8_t *)(x) + (ofs))
 #define FAT_GET_VAL8(x, ofs)       (uint8_t)(*((uint8_t *)(x) + (ofs)))
+#define FAT_GET_VAL8(x, ofs)       (uint8_t)(*((uint8_t *)(x) + (ofs)))
 #define FAT_GET_VAL16(x, ofs)                               \
 …
                   ((uint32_t)(*((uint8_t *)(x) + (ofs) + 2)) << 16) | \
                   ((uint32_t)(*((uint8_t *)(x) + (ofs) + 3)) << 24) )
 #define FAT_SET_VAL8(x, ofs,val)                    \
                  (*((uint8_t *)(x)+(ofs))=(uint8_t)(val))
 #define FAT_SET_VAL16(x, ofs,val) do {              \
                  FAT_SET_VAL8((x),(ofs),(val));     \
 …
 #define FAT_SET_BR_BYTES_PER_SECTOR(x,val)   FAT_SET_VAL16(x, 11,val)
 #define FAT_GET_BR_SECTORS_PER_CLUSTER(x)    FAT_GET_VAL8( x, 13)
 #define FAT_SET_BR_SECTORS_PER_CLUSTER(x,val)FAT_SET_VAL8( x, 13,val)
+#define FAT_GET_BR_SECTORS_PER_CLUSTER(x)    FAT_GET_VAL8( x, 13)
+#define FAT_SET_BR_SECTORS_PER_CLUSTER(x,val)FAT_SET_VAL8( x, 13,val)
 #define FAT_GET_BR_RESERVED_SECTORS_NUM(x)   FAT_GET_VAL16(x, 14)
 …
 #define FAT_SET_BR_TOTAL_SECTORS_NUM16(x,val)FAT_SET_VAL16(x, 19,val)
 #define FAT_GET_BR_MEDIA(x)                  FAT_GET_VAL8( x, 21)
 #define FAT_SET_BR_MEDIA(x,val)              FAT_SET_VAL8( x, 21,val)
+#define FAT_GET_BR_MEDIA(x)                  FAT_GET_VAL8( x, 21)
+#define FAT_SET_BR_MEDIA(x,val)              FAT_SET_VAL8( x, 21,val)
 #define FAT_GET_BR_SECTORS_PER_FAT(x)        FAT_GET_VAL16(x, 22)
 …
 #define FAT_SET_FSINFO_TRAIL_SIGNATURE(x,val) FAT_SET_VAL32(x,508,val)
 #define FAT_FSINFO_TRAIL_SIGNATURE_VALUE  (0xAA550000)
 /*
  * I read FSInfo sector from offset 484 to access the information, so offsets
+/*
+ * I read FSInfo sector from offset 484 to access the information, so offsets
  * of these fields a relative
  */

cpukit/libfs/src/dosfs/fat_file.c

-                      r0893220
+                      r0a7278e
     memset(lfat_fd, 0, sizeof(fat_file_fd_t));
     lfat_fd->links_num = 1;
     lfat_fd->flags &= ~FAT_FILE_REMOVED;
 …
     fat_fd->fat_file_size = new_length;
     return RC_OK;
+}

cpukit/libfs/src/dosfs/msdos_conv.c

r0893220	r0a7278e
275	275	unlen--;
276	276	}
277
	277
278	278	/*
279	279	* Copy the unix filename into the dos filename string upto the end

cpukit/libfs/src/dosfs/msdos_create.c

r0893220	r0a7278e
81	81
82	82	fat_dir_pos_init(&dir_pos);
83
	83
84	84	memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
85	85	memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);

cpukit/libfs/src/dosfs/msdos_dir.c

-                      r0893220
+                      r0a7278e
 #endif
 #include <ctype.h>
+#include <ctype.h>
 #include <stdlib.h>
 #include <unistd.h>
 …
+        {
             char* entry = (char*) fs_info->cl_buf + i;
             /*
              * Is this directory from here on empty ?
 …
                 char* p;
                 int   q;
                 /*
                  * Is this is the first entry of a LFN ?
 …
                     lfn_start =
                       ((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
                     /*
                      * Get the number of entries so we can count down and
 …
                     continue;
+                }
                 /*
                  * Extract the file name into the directory entry. The data is
 …
                  * fit in the directory entry name field.
                  */
                 lfn_entries--;
                 p = entry + 1;
                 o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
                 for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
+                {
                     if (o >= (sizeof(tmp_dirent.d_name) - 1))
                         break;
                     tmp_dirent.d_name[o++] = *p;
 …
+            {
                 fat_dir_pos_t dir_pos;
                 /*
                  * Skip active entries until get the entry to start from.
 …
                     tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
+                }
                 memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
 …
+                }
+            }
             if (count <= 0)
                 break;

cpukit/libfs/src/dosfs/msdos_format.c

-                      r0893220
+                      r0a7278e
   uint32_t total_sectors = sector_cnt;
   int last_percent = -1;
   /*
    * allocate and fill buffer
 …
    * write to consecutive sectors
    */
   while ((ret_val == 0) &&
+  while ((ret_val == 0) &&
          (sector_cnt > 0)) {
     int percent = (sector_cnt * 100) / total_sectors;
 …
     sector_cnt--;
+  }
   msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
 …
     msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
                          "filling error on sector: %d\n", start_sector);
   /*
    * cleanup
 …
     sectors_per_cluster /= 2;
+  }
   do {
     /*
 …
+    }
     sectors_per_fat = ((fat_capacity
+    sectors_per_fat = ((fat_capacity
                         + (bytes_per_sector - 1))
                        / bytes_per_sector);
 …
      * when maximum cluster size is exceeded, we have invalid data, abort...
      */
     if ((sectors_per_cluster * bytes_per_sector)
+    if ((sectors_per_cluster * bytes_per_sector)
         > MS_BYTES_PER_CLUSTER_LIMIT) {
       ret_val = EINVAL;
 …
   uint32_t sectors_per_cluster_adj = 0;
   uint64_t total_size = 0;
   memset(fmt_params,0,sizeof(*fmt_params));
   /*
+  /*
    * this one is fixed in this implementation.
    * At least one thing we don't have to magically guess...
 …
    */
   if (ret_val == 0) {
     if ((rqdata == NULL) ||
+    if ((rqdata == NULL) ||
         (rqdata->fat_num == 0)) {
       fmt_params->fat_num = 2;
 …
+    }
+  }
   if (ret_val == 0)
     msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
                          "number of fats: %d\n", fmt_params->fat_num);
   /*
    * Now we get sort of a loop when determining things:
    * The FAT type (FAT12/16/32) is determined ONLY from the
+   * The FAT type (FAT12/16/32) is determined ONLY from the
    * data cluster count:
    * Disks with data cluster count <  4085 are FAT12.
    * Disks with data cluster count < 65525 are FAT16.
    * The rest is FAT32 (no FAT128 available yet :-)
+   * The rest is FAT32 (no FAT128 available yet :-)
+   *
    * The number of data clusters is the
    * total capacity
+   * The number of data clusters is the
+   * total capacity
    * minus reserved sectors
    * minus root directory ares
    * minus storage needed for the FAT (and its copy/copies).
+   *
+   *
    * The last item once again depends on the FAT type and the cluster count.
+   *
+   *
    * So here is what we do in this formatter:
    * - If a FAT type is requested from the caller, we try to modify
    * the cluster size, until the data cluster count is in range
    * - If no FAT type is given, we estimate a useful FAT type from
+   * - If no FAT type is given, we estimate a useful FAT type from
    * the disk capacity and then adapt the cluster size
    */
+   */
   /*
 …
   /*
    * determine FAT type and sectors per cluster
    * depends on
+   * depends on
    */
   if (ret_val == 0) {
     fmt_params->sectors_per_cluster = 1;
     if ((rqdata != NULL) &&
+    if ((rqdata != NULL) &&
         (rqdata->fattype == MSDOS_FMT_FAT12)) {
       fmt_params->fattype = FAT_FAT12;
+    }
     else if ((rqdata != NULL) &&
+    else if ((rqdata != NULL) &&
              (rqdata->fattype == MSDOS_FMT_FAT16)) {
       fmt_params->fattype = FAT_FAT16;
+    }
     else if ((rqdata != NULL) &&
+    else if ((rqdata != NULL) &&
              (rqdata->fattype == MSDOS_FMT_FAT32)) {
       fmt_params->fattype = FAT_FAT32;
 …
        * are a compromise concerning capacity and efficency
        */
       if (fmt_params->totl_sector_cnt
+      if (fmt_params->totl_sector_cnt
           < ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
         fmt_params->fattype = FAT_FAT12;
         /* start trying with small clusters */
         fmt_params->sectors_per_cluster = 2;
+        fmt_params->sectors_per_cluster = 2;
+      }
       else if (fmt_params->totl_sector_cnt
+      else if (fmt_params->totl_sector_cnt
                < ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
         fmt_params->fattype = FAT_FAT16;
         /* start trying with small clusters */
         fmt_params->sectors_per_cluster = 2;
+        fmt_params->sectors_per_cluster = 2;
+      }
       else {
 …
      * try to use user r

Context Navigation

Changeset 0a7278e in rtems

Legend: