Week 10 Tutorial Questions

printf("%s: command not found\n");

    if (strrchr(program, '/') == NULL) {
        // ...
    }

// A simple Web server

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>

#include "serve_web_page.h"

char *extract_pathname_http_request(char *http_request);
void handle_request(int client_fd);

int main(int argc, char **argv) {

    // create a IPv4 TCP/IP socket
    int sock_fd = socket(AF_INET, SOCK_STREAM, 0);

    // reuse the socket immediately if we restart the server
    int option = 1;
    setsockopt(sock_fd, SOL_SOCKET, SO_REUSEPORT, &option, sizeof(option));

    struct addrinfo hints = {
        .ai_family = AF_INET,
        .ai_socktype = SOCK_STREAM,
        .ai_flags = AI_PASSIVE,
    };

    // construct a port number unlikely to be in use by another COMP1521 student
    // and convert it to a struct addrinfo for the local machine
    struct addrinfo *a;
    char port[6];
    snprintf(port, sizeof port, "%d", 32000 + geteuid() % 32768);
    int s = getaddrinfo(NULL, port, &hints, &a);
    if (s != 0) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
        exit(1);
    }

    // attach the address to the socket
    if (bind(sock_fd, a->ai_addr, a->ai_addrlen) != 0) {
        perror("bind()");
        return 1;
    }

    // specify the maximum number of connections that can be queued for the socket
    if (listen(sock_fd, 8) != 0) {
        perror("listen()");
        return 1;
    }

    printf("\nFrom your web browser test these URLs:\n");
    printf("http://localhost:%s/example.html\n", port);
    printf("http://localhost:%s/bird.html\n\n", port);

    int client_fd;
    while ((client_fd = accept(sock_fd, NULL, NULL)) >= 0) {
        handle_request(client_fd);
    }

    close(sock_fd);

    return 0;
}

// handle 1 request for a web page
void handle_request(int client_fd) {
    // a real server might spawn a client process here to handle the connection
    // so it can accept another connection immediately

    char http_request[4096];
    int n_bytes = read(client_fd, http_request, (sizeof http_request) - 1);
    http_request[n_bytes] = '\0';
    printf("Received this HTTP request:\n%s", http_request);

    // create a stdio stream to client
    FILE *client_stream = fdopen(client_fd, "r+");
    if (client_stream == NULL) {
        perror("fdopen");
        close(client_fd);
        return;
    }

    char *pathname = extract_pathname_http_request(http_request);

    if (pathname == NULL) {
        // not a request we can handle
        fputs(HEADER_400, client_stream);
    } else {
        printf("calling serve_web_page(\"%s\")\n", pathname);
        serve_web_page(pathname, client_stream);
        free(pathname);
    }

    fclose(client_stream);
}

// return a malloced string containing pathname from http request
// NULL is return if not a GET request
// NULL is returned if .. in pathname
// NULL is returned if pathname endswith .c
char *extract_pathname_http_request(char *http_request) {

    char *prefix = "GET /";
    if (strncmp(http_request, prefix, strlen(prefix)) != 0) {
        return NULL;
    }

    char *path_start = http_request + strlen(prefix);
    char *following_space = strchr(path_start, ' ');
    if (following_space == NULL) {
        return NULL;
    }
    int pathname_length = following_space - path_start;
    if (pathname_length < 1) {
        return NULL;
    }

    char *pathname = strndup(path_start, pathname_length);

    if (pathname == NULL) {
        return NULL;
    }

    if (strstr(pathname, "..") != NULL) {
        // prevent directory traversal
        free(pathname);
        return NULL;
    }

    if (pathname_length > 1 && strcmp(pathname + pathname_length - 2, ".c") == 0) {
        // prevent C source being served
        free(pathname);
        return NULL;
    }

    return pathname;
}

#define HEADER_200 "HTTP/1.1 200 OK\r\nContent-type: text/html\r\n\r\n"
#define HEADER_400 "HTTP/1.1 400 Bad request\r\n\r\n"
#define HEADER_404 "HTTP/1.1 404 Not Found\r\n\r\n"

void send_web_page(char *url, FILE *client_stream);

int getaddrinfo (char *Hostname, char *Service,
    struct addrinfo *Hints, struct addrinfo **Results);

struct addrinfo {
    int ai_family;            // protocol family for socket
    int ai_socktype;          // oscket type
    int ai_protocol;          // protocol
    socklen_t ai_addrlen;     // address length
    struct sockaddr *ai_addr; // address
    struct addrinfo *ai_next; // next `struct addrinfo'
};

// Fetch data from a URL, separating header and body
// Adapted from an example on https://curl.haxx.se/
// Written by Daniel Sternberg
// Modified by John Shepherd

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

#include <curl/curl.h>

static size_t write_data (void *, size_t, size_t, void *);

int main (int argc, char *argv[])
{
	// check that they gave us a URL
	if (argc < 2) {
		fprintf (stderr, "Usage %s URL\n", argv[0]);
		exit (1);
	}

	// init the curl session
	curl_global_init (CURL_GLOBAL_ALL);
	CURL *cp = curl_easy_init ();
	// set URL to get
	curl_easy_setopt (cp, CURLOPT_URL, argv[1]);
	// no progress meter please
	curl_easy_setopt (cp, CURLOPT_NOPROGRESS, 1L);
	// send all data to this function
	curl_easy_setopt (cp, CURLOPT_WRITEFUNCTION, write_data);
	// we want the headers be written to stdout
	curl_easy_setopt (cp, CURLOPT_HEADERDATA, stdout);
	// we want the body be written to stdout
	curl_easy_setopt (cp, CURLOPT_WRITEDATA, stdout);
	// get it!
	curl_easy_perform (cp);
	// cleanup curl stuff
	curl_easy_cleanup (cp);

	return 0;
}

static size_t
write_data (void *ptr, size_t size, size_t nmemb, void *stream)
{
	size_t written = fwrite (ptr, size, nmemb, (FILE *) stream);
	return written;
}

    # clean up stack frame
    lw    $s3, -20($fp)
    lw    $s2, -16($fp)
    lw    $s1, -12($fp)
    lw    $s0, -8($fp)
    lw    $ra, -4,($fp)
    la    $sp, 4($fp)
    lw    $fp, ($fp)
    jr    $ra           # BUG: try removing this

int max (int a[], int n)
{
	int big = -1;
	for (int i = 0; i < n; i++) {
		if (a[i] > big) big = a[i];
	}
	return big;
}

spim -file max.s