Электронная библиотека книг Александра Фролова и Григория Фролова.
 
Библиотека
Братьев
Фроловых
Электронная библиотека книг Александра Фролова и Григория Фролова.
Библиотека системного программиста
Программирование на JAVA
ПК. Шаг за шагом
Другие книги
Восстановление данных
Антивирусная защита
Статьи для
программистов
Пользователю компьютера
[Назад]

Грузите файлы на Web-сервер браузерами. Часть 2

17.04.1999

А.В. Фролов, Г.В. Фролов
Окончание. Начало # 3 1999 г. c. 78

Исходные тексты программы FUPLOAD

Исходные тексты программы FUPLOAD расположены в трех файлах: fileupl.c, parse.c и process.c. Файл fileupl.c представлен (с сокращениями) в листинге 2. Более полный вариант можно найти на сервере www.pcworld.ru.

Функция GetExtensionVersion реализована стандартным для приложений ISAPI образом и не представляет особого интереса. Что же касается функции HttpExtensionProc, то именно она получает управление, когда посетитель отправляет заполненную форму нашему расширению сервера Web.

Первым делом функция HttpExtensionProc вызывает функцию readClientData, принимающую данные от браузера. Эти данные сохраняются в буфере с адресом lpData. Если данные приняты успешно, функция HttpExtensionProc получает имя временного файла, вызывая для этого функцию GetTempFileName. Заметим, что эта операция выполняется внутри критической секции, так как к нашему расширению могут одновременно обратиться несколько пользователей.

Принятые данные, а также имя временного файла передаются функции parseData. В ее задачу входит разбор блоков данных с выделением имен и значений полей. Функция parseData формирует начальную часть документа HTML, посылаемого посетителю в ответ на отправку формы. Указанный документ готовится в буфере szBuf.

Вторая задача функции parseData — выделение из принятых данных файла, заданного посетителем в форме, и его сохранение во временном файле. Последнее действие функции HttpExtensionProc — вызов функции processData, ей передается путь к временному файлу и адрес буфера, в который следует записать результат обработки файла. Функция processData записывает этот результат как финальную часть документа HTML.

Сформированный документ HTML отправляется пользователю методом replyOK.

Листинг файла fileupl.c снабжен комментариями и в дополнительном описании не нуждается.

Определенные затруднения может вызвать реализация процедуры разбора данных, присланных браузером. Соответствующие функции определены в файле parse.c. (см. листинг 3).

Для сокращения листинга функции parseData, выполняющей основную работу по сканированию принятых данных, мы подготовили набор макрокоманд.

Макрокоманда IS_BOUNDARY проверяет, не установлен ли указатель lpCurrent (перемещающийся в процессе сканирования по буферу принятых данных) на разделитель блоков. В качестве разделителя берется первая строка принятых данных, выделяемая функцией GetMIMEBoundary.

Макрокоманда CHECK_DATA_END вызывается в процессе сканирования для проверки достижения конца буфера с принятыми данными.

С помощью макрокоманды FIND_BOUNDARY мы реализовали поиск разделителя блоков. Макрокоманда FIND_FIELD_NAME предназначена для поиска строки «name=» в заголовке блока, а FIND_ HEADER_END — для поиска конца заголовка блока.

При помощи макрокоманды GET_FIELD_NAME мы извлекаем имя поля, а при помощи макрокоманды GET_FIELD_DATA — данные, записанные пользователем в поле формы.

Макрокоманды GET_FILE_NAME и GET_FILE используются, соответственно, для получения пути к файлу, отправленному пользователем, и для извлечения данных этого файла с записью во временный файл.

Остановимся подробнее на работе функции parseData.
Прежде всего эта функция вызывает функцию GetMIMEBoundary. Выделенный с ее помощью разделитель записывается в массив szBoundary. Дополнительно мы формируем еще один массив — szFileBoundary, который используется при поиске конца файла в принятых от посетителя данных.

Далее функция parseData формирует в буфере szBuf начальный фрагмент документа HTML, отправляемого посетителю в ответ на присланную форму. В процессе подготовки этого документа мы пользуемся временным буфером szBuf1.

Сканирование принятых от браузера данных выполняется в цикле. При этом адрес начала буфера находится в указателе lpUploadedData, а адрес текущей позиции — в указателе lpCurrent. Переменную i мы используем для подсчета числа байтов обработанных данных.

Цикл сканирования начинает свою работу с поиска разделителя, имени поля и копирования этого имени в массив szFieldName. Полученное имя поля записывается в выходной документ HTML. Далее мы проверяем, относится ли текущий блок к файлу. Если в заголовке блока есть строка ”filename=”, мы считаем, что блок содержит файл. В этом случае функция parseData копирует имя файла макрокомандой GET_FILE_NAME в массив szFieldFileName и записывает его в выходной документ HTML. Вслед за этим функция parseData находит конец заголовка блока и копирует данные во временный файл. Обычные поля формы обрабатываются макрокомандой GET_FIELD_DATA. Их содержимое копируется в выходной документ HTML. Завершив сканирование, функция parseData возвращает указатель на буфер с указанным документом.

Теперь немного о функции processData, исходный текст которой приведен в листинге 4. Эта функция получает управление, когда данные, переданные посетителем, уже приняты и разобраны, а содержимое переданного файла скопировано во временный файл.

Изменив функцию processData, вы можете выполнить произвольную обработку полученного файла. После обработки файл следует удалить функцией DeleteFile, как это сделано в листинге 4. Результат обработки файла функция processData записывает в буфер szBuf как завершающий фрагмент документа HTML.

ОБ АВТОРАХ

Братья Александр Вячеславович и Григорий Вячеславович Фроловы — авторы серий книг «Библиотека системного программиста» и «Персональный компьютер. Шаг за шагом». E-mail: alexandre@frolov.pp.ru; Web: http://www.frolov.pp.ru


Листинг 2

Получение и обработка данных (файл fileupl.c)

#include <windows.h>
#include <httpext.h>
// ===============================================
// Прототипы функций, определенных в приложении
// ===============================================
  . . .
// ===============================================
// Функция GetExtensionVersion
// ===============================================
BOOL WINAPI 
GetExtensionVersion(HSE_VERSION_INFO *pVer)
{
  . . .
}
// ===============================================
// Функция HttpExtensionProc
// ===============================================
DWORD WINAPI 
HttpExtensionProc(EXTENSION_CONTROL_BLOCK *lpECB)
{
  LPVOID lpData;
  int  nStatus = 0;
  CHAR szFileName[512];
  CHAR szBuf[4096];
  CHAR szBuf1[4096];
  CRITICAL_SECTION csGetTempFilename;
// Получаем данные от браузера
  lpData = readClientData(lpECB, &nStatus);
  if(lpData != NULL && nStatus == 0)
  {
    InitializeCriticalSection(&csGetTempFilename);
    EnterCriticalSection(&csGetTempFilename);
    GetTempFileName("c:\\upload", "$up", 0,
      szFileName);
    LeaveCriticalSection(&csGetTempFilename);
    DeleteCriticalSection(&csGetTempFilename);
    parseData(lpData, lpECB->cbTotalBytes, 
      szBuf, szFileName);
    processData(szFileName, szBuf1);
    strcat(szBuf, szBuf1);
    return replyOK(lpECB, szBuf);
  }

  else
    return replyError(lpECB);
}
// ===============================================
// Функция readClientData
// Получение данных от браузера
// ===============================================
LPVOID readClientData(
     EXTENSION_CONTROL_BLOCK *lpECB, 
     int *nStatus)
{
  DWORD cbReaded;
  DWORD nBufferPos;
  DWORD nBytesToCopy;
  LPVOID lpTemp = NULL;
  // Код завершения
  *nStatus = 0;
  // Нулевой код состояния - признак 
  // успешного выполнения
  lpECB->dwHttpStatusCode = 0;
  // Определяем, есть ли данные для чтения
  if(lpECB->cbTotalBytes != 0)
  {
    // Заказываем буфер памяти для чтения 
    // принятых данных
    if(!(lpTemp = (LPVOID)LocalAlloc(LPTR, 
      lpECB->cbTotalBytes)))
    {
      // Если памяти не хватает, завершаем работу
      // с установкой кода ошибки и возвращаем
      // значение NULL
      *nStatus = HSE_STATUS_ERROR;
      return NULL;
    }
    // Копируем в буфер предварительно 
    // считанные данные
    memcpy(lpTemp, lpECB->lpbData, 
      lpECB->cbAvailable);
    // Устанавливаем указатель текущей позиции
    // в буфере после скопированных данных
    nBufferPos = lpECB->cbAvailable;
    // Определяем, сколько данных нужно считать
    // дополнительно с помощью функции ReadClient
    nBytesToCopy = 
      lpECB->cbTotalBytes - lpECB->cbAvailable;
    cbReaded = nBytesToCopy;
    // Если не все данные находятся в буфере 
    // предварительного чтения, запускаем цикл 
    // копирования оставшихся данных
    if(nBytesToCopy > 0)
    {
      while(1)
      {
        // Читаем очередную порцию данных в текущую
        // позицию буфера
        if(!lpECB->ReadClient(lpECB->ConnID, 
          (LPVOID)((LPSTR)lpTemp + nBufferPos), 
          &cbReaded))
        { 
          DWORD rc = GetLastError();
          traceUpload("ReadClient Error", rc);
          *nStatus = HSE_STATUS_ERROR;
          return NULL;
          break;
        }
        // Уменьшаем содержимое переменной 
        // nBytesToCopy, в которой находится 
        // размер непрочитанных данных
        nBytesToCopy -= cbReaded;
        // Продвигаем указатель текущей 
        // позиции в буфере на количество 
        // прочитанных байт данных
        nBufferPos   += cbReaded;
        // Когда копировать больше нечего, 
        // прерываем цикл
        if(nBytesToCopy <= 0l)
        break;
      }
    }

    // В случае успешного копирования возвращаем
    // адрес буфера с прочитанными данными
    return lpTemp;
  }
  // Если данных для чтения нет, завершаем
  // работу с установкой кода ошибки
  else
  {
    *nStatus = HSE_STATUS_ERROR;
    // В случае ошибки вместо адреса буфера
    // с прочитанными данными возвращается
    // значение NULL
    return NULL;
  }
}

// ===============================================
// replyOK
// ===============================================
DWORD 
replyOK(EXTENSION_CONTROL_BLOCK *lpECB, 
        LPSTR szBuf)
{
  // Отправляем созданный документ HTML
  if(!lpECB->ServerSupportFunction(lpECB->ConnID,
    HSE_REQ_SEND_RESPONSE_HEADER, NULL, 
    NULL, (LPDWORD)szBuf))
  {
    return HSE_STATUS_ERROR;
  }
  lpECB->dwHttpStatusCode = 200;
  return HSE_STATUS_SUCCESS;
}
// ===============================================
// replyError
// Отправка сообщения об ошибке
// ===============================================
DWORD 
replyError(EXTENSION_CONTROL_BLOCK *lpECB)
{
  . . .
}




Листинг 3

Разбор данных (файл parse.c)

#include <windows.h>
#include <stdio.h>
#include <string.h>
#define IS_BOUNDARY (memcmp(lpCurrent, szBoundary, \
  strlen(szBoundary)) == 0)
#define CHECK_DATA_END    \
  if(i >= dwDataSize)     \
  {                       \
    bEndOfFile = TRUE;    \
    break;                \
  }
#define FIND_BOUNDARY       \
  for(;; i++, lpCurrent++)  \
  {                         \
    CHECK_DATA_END          \
    if(IS_BOUNDARY)         \
      break;                \
  }                         \
  if(bEndOfFile)            \
    break;
#define FIND_FIELD_NAME     \
  for(;; i++, lpCurrent++)  \
  {                         \
    CHECK_DATA_END          \
    if(memcmp(lpCurrent, ”name=”, 5) == 0) \
      break;                \
  }                         \
  if(bEndOfFile)            \
    break;                  \
  lpCurrent += 6; i += 6;
#define FIND_HEADER_END     \
  for(;; i++, lpCurrent++)  \
  {                         \
    CHECK_DATA_END          \
    if(memcmp(lpCurrent, ”\r\n\r\n”, 4) == 0) \
      break;                \
  }                         \
  if(bEndOfFile)            \
    break;                  \
  lpCurrent += 4; i += 4;
#define GET_FIELD_NAME             \
  for(j=0;; j++, i++, lpCurrent++) \
  {                                \
    CHECK_DATA_END                 \
    szFieldName[j] = *lpCurrent;   \
    if(*lpCurrent == ‘”‘)          \
      break;                       \
  }                                \
  if(bEndOfFile)                   \
    break;                         \
  szFieldName[j] = ‘\0’;
#define GET_FILE_NAME              \
  for(j=0;; j++, i++, lpCurrent++) \
  {                                \
    CHECK_DATA_END                 \
    szFieldFileName[j] = *lpCurrent; \
    if(*lpCurrent == ‘”‘)            \
      break;                       \
  }                                \
  if(bEndOfFile)                   \
    break;                         \
  szFieldFileName[j] = ‘\0’;
#define GET_FIELD_DATA             \
  for(j=0;; j++, i++, lpCurrent++) \
  {                                \
    CHECK_DATA_END                 \
    szFieldValue[j] = *lpCurrent;  \
    if(IS_BOUNDARY)                \
      break;                       \
  }                                \
  if(bEndOfFile)                   \
    break;                         \
  szFieldValue[j] = ‘\0’;        
#define GET_FILE                       \
  downloaded = fopen(szOutFile, ”wb”); \
  while(TRUE)                          \
  {                                    \
    if(memcmp(lpCurrent, szFileBoundary, \
      strlen(szFileBoundary)) == 0)      \
      break;                           \
    fputc(*lpCurrent, downloaded);     \
    lpCurrent++; i++;                  \
    CHECK_DATA_END                     \
  }                                    \
  fclose(downloaded);
// ====================================================
// Функция GetMIMEBoundary
// Поиск разделителя в буфере.
// Параметры:
//   lpDataMIME - адрес буфера с данными MIME
//   lpBuffer   - адрес буфера для записи разделителя
//   dwBufSize  - размер буфера с данными MIME
// ====================================================
BOOL GetMIMEBoundary(LPVOID lpDataMIME, 
                     LPSTR lpBuffer, DWORD dwBufSize)
{
  LPSTR lpCurrent;
  DWORD dwOffset;
  BOOL  fFound;
  
  // Устанавливаем признак успешного поиска
  fFound = TRUE;
  // Ищем конец первой строки
  for(lpCurrent = lpDataMIME, 
    dwOffset = 0;;lpCurrent++, dwOffset++)
  {
    // Сравниваем с концом строки
    if(!memcmp(lpCurrent,”\r\n”,2))
      break;
    // Если достигнут конец буфера,
    // сбрасываем признак успешного поиска
    // и прерываем работу цикла
    if(dwOffset >= dwBufSize)
    {
      fFound = FALSE;
      break;
    }
    // Копируем очередной символ разделителя
    *(lpBuffer + dwOffset) = *lpCurrent;
  }
  // Если разделитель найден, закрываем строку
  // разделителя двоичным нулем
  if(fFound)
    *(lpBuffer + dwOffset)= ‘\0’;  
  // Возвращаем признак успешного или
  // неуспешного поиска
  return fFound;
}
// ====================================================
// Функция parseData
// ====================================================
LPSTR 
parseData(LPVOID lpUploadedData, DWORD dwDataSize, 
          LPSTR szBuf, LPSTR szOutFile)
{
  FILE *downloaded;
  CHAR szBuf1[1024];
  CHAR szBoundary[256];
  CHAR szFileBoundary[256];
  CHAR szFieldName[256];
  CHAR szFieldValue[4096];
  CHAR szFieldFileName[512];
  LPSTR lpCurrent;
  DWORD i, j;
  BOOL bEndOfFile = FALSE;
  if(!GetMIMEBoundary(lpUploadedData, 
        szBoundary, dwDataSize))
    return NULL;
  strcpy(szFileBoundary, ”\r\n”);
  strcat(szFileBoundary, szBoundary);
  strcpy(szBuf, ”Content-type: text/html\r\n\r\n”
    ”<!DOCTYPE HTML PUBLIC”
    ” \”-//W3C//DTD HTML 3.2//EN\”>\r\n”
    ”<HTML><HEAD><TITLE>File upload Results”
    ”</TITLE></HEAD>”
    ”<BODY BGCOLOR=#FFFFFF>”
    ”<H1>Form processing results</H1>\r\n”);
  wsprintf(szBuf1, ”<p><b>Boundary</b>: %s\n”,
    szBoundary);
  strcat(szBuf, szBuf1);
  lpCurrent = lpUploadedData;
  i = 0;
  while(TRUE)
  {
    FIND_BOUNDARY
    FIND_FIELD_NAME
    GET_FIELD_NAME
    wsprintf(szBuf1, ”<br><b>name</b>: %s”,
      szFieldName);
    strcat(szBuf, szBuf1);
    lpCurrent++;
    i++;
    // Проверяем, есть ли имя файла
    if(memcmp(lpCurrent, ”; filename=”, 10) == 0)
    {
      lpCurrent += 12;
      // Копируем имя файла
      GET_FILE_NAME
      wsprintf(szBuf1, ”, <b>filename</b>: %s%”,
        szFieldFileName);
      strcat(szBuf, szBuf1);
      FIND_HEADER_END
      GET_FILE
      wsprintf(szBuf1, ”, <b>saved as</b>: %s%\n”, 
        szOutFile);
      strcat(szBuf, szBuf1);
    }
    // Обычное поле. Получаем данные
    else
    {
      lpCurrent += 4;
      GET_FIELD_DATA
      wsprintf(szBuf1, ”, <b>value</b>: %s%\n”, 
        szFieldValue);
      strcat(szBuf, szBuf1);
    }
    if(i > dwDataSize)
      break;
  }
  return szBuf;
}


Листинг 4

Шаблон функции для обработки данных (файл process.c)

#include <windows.h>

// ====================================================
// Функция processData
// ====================================================
LPSTR
processData(LPSTR szFileName, LPSTR szBuf)
{
  wsprintf(szBuf, 
    ”<hr><p>Processing file: %s\n”, szFileName);

//  . . .
//  Добавьте ваш код для обработки загруженного 
//  файла на сервере Web
//  . . .

//  DeleteFile(szFileName);
  strcat(szBuf, ”</BODY></HTML>\n”);
  return szBuf;
}

Журнал "Мир ПК", #04, 1999 год // Издательство "Открытые Системы" (http://www.osp.ru/)
Постоянный адрес статьи: http://www.osp.ru/pcworld/1999/04/082.htm

[Назад]


Создание интернет-магазинов: http://www.shop2you.ru/ © Александр Фролов, Григорий Фролов, 1991-2016