sprintf() сошла с ума

Вы вызываете readPage с недопустимым указателем path - он указывает на память, ранее выделенную указателем method, которая освобождается непосредственно перед вызовом readPage. Следующий malloc может повторно использовать эту память, и тогда может случиться что угодно...

Ну, этого явно не может быть :-)

Я предполагаю, что ваша куча уже ужасно повреждена.

Я бы посмотрел на фактические значения указателя, используемые путем к файлу, вводом и базой. Интересно, обнаружите ли вы, что ввод очень близок к пути к файлу?

Я бы также посмотрел, как изначально были созданы путь к файлу, база и т. Д., Может ли у вас быть переполнение буфера?

Попробуйте этот код:

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
    const char* BASE_DIR = "/home/steve/cps730";
    const char* filepath = "/page2.html";
    int memory_alloc = strlen(filepath);
    memory_alloc += strlen(BASE_DIR)+1;
    printf("\n\nAlloc: %d",memory_alloc);
    char *input = (char*)malloc(memory_alloc);
    printf("\n\nBASE: %s\nPATH: %s\n\n",BASE_DIR,filepath);
    sprintf(input, "%s%s",BASE_DIR,filepath); //   :(

    printf("\n\nPATH: %s\n\n",input);

    return 0;
}

Если это не проблема, то где-то в коде должно быть что-то не так. Вот как иногда может проявляться неопределенное поведение (искажает работу несвязанного кода).

(Кстати, я не добавлял +1 к обоим вызовам strlen, так как конкатенированная строка по-прежнему будет иметь только один нуль-терминатор.)

Поскольку значение BASE_DIR повторяется, BASE_DIR или filepath, вероятно, перекрываются с input памятью.

Убедитесь, что и BASE_DIR, и filepath действительно выделили память.

Первая попытка — просто сделать локальную копию BASE_DIR и filepath перед вызовом sprintf.

А-а-а - азарт погони, когда вопрос трансформируется, пока мы пытаемся решить проблему!

Текущий код выглядит так:

const char *BASE_DIR = "/home/steve/cps730";

//Handles the header sent by the browser
char* handleHeader(char *header){
    //Method given by browser (will only take GET, POST, and HEAD)
    char *method;
    method = (char*)malloc(strlen(header)+1);
    strcpy(method,header);
    method = strtok(method," ");

    if(!strcmp(method,"GET")){
        char *path = strtok(NULL," ");
        if(!strcmp(path,"/")){
                path = (char*)malloc(strlen(BASE_DIR)+1+12);
                strcpy(path,"/index.html");
        }
        free(method);
        return readPage(path);
    }
    ...

Вопрос: если это выполняется на веб-сервере, безопасно ли использовать небезопасную для потоков функцию strtok()? Я собираюсь предположить: «Да, это безопасно», хотя я не совсем в этом уверен. Вы напечатали строку header? Вы напечатали значение path? Вы действительно намеревались слить выделенные path? Вы поняли, что последовательность malloc() + strcpy() не копирует BASE_DIR в path?

Первоначальная версия кода заканчивалась:

 printf("\n\nPATH: %s\n\n", filepath);

Отсюда исходный предложенный частичный ответ:

Вы форматируете в input; вы печатаете из filepath?

Какова вероятность того, что filepath указывает на уже освобожденную память? Когда вы выделяете память, вы можете получить что-нибудь, происходящее с квазислучайной областью, на которую раньше указывал filepath. Другая возможность может заключаться в том, что filepath является указателем на локальную переменную в функции, которая вернула значение, поэтому он указывает на какое-то случайное место в стеке, которое повторно используется другим кодом, например sprintf().

Я также упомянул в комментарии, что вам, возможно, потребуется убедиться, что malloc() объявлено, и проверить возвращаемое из него значение. Приведение '(char *)' не является обязательным в C (оно есть в C++), и многие предпочитают не включать приведение, если код строго написан на C и не является двуязычным в C и C++.

Этот код работает для меня:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)
{
    const char *BASE_DIR = "/home/steve/cps730";
    const char *filepath = "/page2.html";

    int memory_alloc = strlen(filepath) + 1;
    memory_alloc += strlen(BASE_DIR) + 1;
    printf("\n\nAlloc: %d", memory_alloc);
    char *input = (char*)malloc(memory_alloc + 9000);
    printf("\n\nBASE: %s\nPATH: %s\n\n", BASE_DIR, filepath);
    sprintf(input, "%s%s", BASE_DIR, filepath);

    printf("\n\nPATH: %s\n\n", filepath);
    printf("\n\nPATH: %s\n\n", input);

    return(0);
}

Он производит посторонние пустые строки плюс:

Alloc: 31
BASE: /home/steve/cps730
PATH: /page2.html
PATH: /page2.html
PATH: /home/steve/cps730/page2.html

Самый простой способ выяснить, что происходит, — проследить выполнение в отладчике (возможно, перейдя к отслеживанию ассемблерного кода).

Несколько предположений о том, что может происходить:

• повреждение памяти другим потоком (кажется маловероятным, если это легко повторить)
• поврежденная куча (также кажется маловероятным, поскольку вы выгружаете 2 строки компонентов после вызова malloc())
• как упоминал Джонатан Леффлер в комментарии, вам может не хватать заголовка (возможно, stdio.h), и компилятор генерирует неверную последовательность вызова/очистки стека для вызовов printf/sprintf. Я ожидаю, что вы увидите некоторые предупреждения во время компиляции, если это так, и вам следует принять к сведению.

Какой компилятор/цель вы используете?

Чтобы сделать это правильно, я бы изменил код на:

/* CHANGED: allocate additional space for "index.html" */
method = (char*)malloc(strlen(header)+1+10);
strcpy(method,header);
method = strtok(method," ");

if(!strcmp(method,"GET")){
    char *path = strtok(NULL," ");
    if(!strcmp(path,"/")){
             /* CHANGED: don't allocate new memory, use previously allocated */
             strcpy(path,"/index.html");
    }
    /* CHANGED: call function first and free memory _after_ the call */
    char *result = readPage(path);
    free(method);
    return result;
}

Предложения

В программе явно нет ничего плохого. (Обновление: ну, теперь кое-что очевидно. За первый час было опубликовано всего несколько строк, и в них не было серьезных ошибок. ) Вам придется опубликовать больше. Вот несколько идей:

1. malloc(3) возвращает void *, поэтому его не нужно приводить. Если вы получаете предупреждение, это, скорее всего, означает, что вы не включили <stdlib.h>. Если вы не, вы должны. (Например, в 64-битной системе отсутствие прототипирования malloc(3) может быть довольно серьезным. Некоторые из 64-битных сред на самом деле не поддерживают K&R C. :-)
2. Говоря о предупреждениях, пожалуйста, убедитесь, что вы включили их все. С помощью gcc вы можете включить большинство из них с помощью -Wall.
3. Вы не проверяете возвращаемое значение malloc(3) на наличие ошибки.
4. Используйте отладчик памяти, например Электрический забор. Вариантов много, смотрите мою ссылку.