Commit 23a41e82 authored by Diwaker Nithyanandan's avatar Diwaker Nithyanandan
Browse files

Upload New File

parent df7bcc9c
#include <assert.h>
#include "httplib.h"
/**
* Eine Veränderte strcat Funktion.
* Verkettet ein String mit einem Char-Array in den String-Pointer,
* ohne auf Nullbytes zu prüfen. Zudem wird die groesse des Str-Array angepasst.
* @param des: String-Pointer mit den der neue Text verkettet wird.
* src: Ein Char-Array mit den neuen Text.
* len: Die Länge des neuen Text in Byte.
* @return Der Verkettete String in den dest-Pointer.
*/
string* str_cat(string* dest, const char* src,size_t len){
//fehlerabfangen
if(len < 0 ) return NULL;
if(src == NULL) return NULL;
if(dest == NULL) return NULL;
if(dest->str == NULL) return NULL;
//Die größe des dest-Array wird um len bytes erweitert.
dest->str = realloc(dest->str, dest->len + (len));
if (dest->str == NULL){
return NULL;
}
//erstellt ein Pointer zum letzten Eintrag im Array von der dest-Variable.
char *ptr_last_ent = 0;
ptr_last_ent = (char*)(dest->str+dest->pos+1);
//schreibt den neuen Text an dest-String.
memcpy(ptr_last_ent ,src, len);
//passt die länge des Ausgabe-String an.
dest->len += len -1 ;
dest->pos += len -1;
return dest;
}
string* new_string(size_t len) {
string* str = calloc(sizeof(string), 1);
if(str == NULL) {
exit(2);
}
str->str = calloc(len, 2);
if(str->str == NULL) {
exit(3);
}
str->len = len * 2;
str->pos = 0;
return str;
}
http_req* new_request(size_t len) {
http_req* req = calloc(sizeof(string), 1);
if(req == NULL) {
exit(2);
}
return req;
}
req_line* new_req_line(size_t len) {
req_line* req = calloc(sizeof(string), 1);
if(req == NULL) {
exit(2);
}
return req;
}
http_resp* new_response(size_t len) {
http_resp* resp = calloc(sizeof(string), 1);
if(resp == NULL) {
exit(2);
}
return resp;
}
resp_line* new_resp_line(size_t len) {
req_line* req = calloc(sizeof(string), 1);
if(req == NULL) {
exit(2);
}
return req;
}
void print_string(string* str) {
for(int i=0; i <= str->pos; i++) {
putchar(str->str[i]);
}
}
/**
* es wird
* @param src
* @param len
* @return
*/
string* cpy_str(const char* src, size_t len) {
string* dest = new_string(len);
memcpy(dest->str, src, len);
dest->pos=len-1;
return dest;
}
void free_str(string* str) {
assert(str != NULL);
assert(str->str != NULL);
free(str->str);
free(str);
}
size_t get_length(string* str) {
assert(str != NULL);
return str->pos + 1;
}
char* get_char_str(string* str) {
assert(str != NULL);
return str->str;
}
/**
* ich habe schon mal die readerfunktion angefangen, aber die läuft nicht.
* kannst gucken was falsch ist, oder einfach eine neue schreiben.
* @param path
* @return der Text in der Datei.
*/
char* readFile(string* path){
int BUFFER_SIZE = 1024*1024;
string* strLine = new_string(BUFFER_SIZE);
FILE *fp;
fp = fopen("/home/etiuser/Test/index.html", "r");
while (fgets(strLine->str, BUFFER_SIZE, (FILE*)fp) != NULL){
str_cat(path,strLine->str ,get_length(strLine));
}
fclose(fp);
}
//sucht den seach char im text und gibt den index davon zurück
size_t getIndex(const char* text, char search, size_t i){
while (text[i] != search )i++;
return i;
}
/**
* schreibt die Parameter der Anfrage in den http-request construct
* @param request die Anfrage
* @param req zu füllenden http-request construct
*/
void split_Request(string* request, http_req* req){
size_t i = 0;
size_t test = 0;
string* resp_line = new_string(1024*1024);
//kopiert die erste Zeile der Request
i = getIndex(request->str,'\n',i);
resp_line = cpy_str(request->str,i);
//koppiert den ersten befehl in http_methode.
i = getIndex(resp_line->str,'/',0)-1;
req->request_line->http_methode = cpy_str(resp_line->str,i);
test = i +1 ;
i = getIndex(resp_line->str+test,' ',0);
req->request_line->http_ressource = cpy_str(resp_line->str+test,i);
test = test + i+1;
i = getIndex(resp_line->str+test,'\r',0);
req->request_line->http_prot_ver = cpy_str(resp_line->str+test,i);
}
/**
*
* @param http_header
* @param size
* @return
*/
string* get_HTTP_Header(http_resp* http_header,size_t size){
string* header= new_string(1024*1024);
char* cont_typ;
char* cont_length;
char* header_end;
header_end = "\r\n\r\n";
header = cpy_str(http_header->response_line->http_prot_ver->str,strlen(http_header->response_line->http_prot_ver->str));
str_cat(header,http_header->response_line->http_code->str,strlen(http_header->response_line->http_code->str));
str_cat(header,http_header->response_line->http_status->str,strlen(http_header->response_line->http_status->str));
cont_typ ="\r\nContent-Type: text/html\r\n";
str_cat(header,cont_typ,strlen(cont_typ));
//TODO die länge als char in den Header schreiben.
cont_length = "Content-Length: 200";
str_cat(header,cont_length,strlen(cont_length));
//str_cat(header,(char*)size,size);
str_cat(header,header_end,strlen(header_end));
return header;
}
/**
* Schreibt die Informationen über den Request zurück
* man kann z.B. das so machen, das in http status steht, ob es funktioniert hat... und bei status 300 äffnet man dan ein html-Fehlerfenster.
* @param request mit den HTML Informationen
* @param response zu füllenden HTML verarbeitungs Informationen.
*/
void fill_Html_Resp(http_req* request ,http_resp* response ){
response->response_line->http_prot_ver = cpy_str(request->request_line->http_prot_ver->str,request->request_line->http_prot_ver->len);
char* code = " 200 ";
response->response_line->http_code = cpy_str(code,strlen(code));
char* status = " OK ";
response->response_line->http_status = cpy_str(status,strlen(status));
}
/**
* erstellt die html seite, wenn man nach index.html auf dem server sucht.
* @param req wo die Informationen der Anfrage steht.
* @return gibt den index.html als html seite mit bestimten informationen.
*/
string* get_html_index(http_req* req){
string* html_body = new_string(1024*1024);
char* filler;
char* bBody;
bBody = "<html>"
"<body>"
"<h1>Willkommen im externen Bereich!</h1>"
"<pre>";
html_body = cpy_str(bBody,strlen(bBody));
filler = "\r\nHtml-Methode:";
str_cat(html_body, filler ,strlen(filler)+1);
str_cat(html_body, req->request_line->http_methode->str ,strlen(req->request_line->http_methode->str)+1);
filler = "\r\nHtml-Ressource:";
str_cat(html_body, filler ,strlen(filler)+1);
str_cat(html_body, req->request_line->http_ressource->str ,strlen(req->request_line->http_ressource->str)+1);
filler = "\r\nHtml-Protokoll-Version:";
str_cat(html_body, filler ,strlen(filler)+1);
str_cat(html_body, req->request_line->http_prot_ver->str ,strlen(req->request_line->http_prot_ver->str)+1);
bBody = "</pre>"
"</body>"
"</html>";
str_cat(html_body, bBody ,strlen(bBody)+1);
return html_body;
}
string* get_html_body(string* req){
string* html_body = new_string(1024*1024);
char* filler;
char* bBody;
bBody = "<html>"
"<body>"
"<pre>";
html_body = cpy_str(bBody,strlen(bBody));
str_cat(html_body, req->str ,get_length(req));
bBody = "</pre>"
"</body>"
"</html>";
str_cat(html_body, bBody ,strlen(bBody)+1);
return html_body;
}
/**
* erstellt die html seite, und liest eine Datei aus
* @param req wo die Informationen der Anfrage steht.
* @return gibt den index.html als html seite mit bestimten informationen.
*/
string* get_file_index(http_req* req){
string* html_body = new_string(1024*1024);
char* filler;
char* bBody;
FILE * fPointer;
fPointer = fopen(req->request_line->http_ressource->str, "r");
//wenn null fehlermeldungf
char singleLine[150];
while (!feof(fPointer)){
fgets(singleLine, 150, fPointer);
printf(singleLine);
}
html_body = cpy_str(bBody,strlen(bBody));
str_cat(html_body, html_body->str ,html_body->len);
//str_cat(html_body, bBody ,strlen(bBody)+1);
fclose(fPointer);
return html_body;
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment