自己动手写HTTP服务--myhttpd

/** sol12.5.c
** ------------------------------------------------------------
A version of webserv that puts some typical CGI
variables into the environment before calling
exec is
sol12.5.c.
Three kinds of variables are demonstrated in this solution:
variables about the server,
variables sent as part of the http header,
and variables about the client.

** ------------------------------------------------------------
**
**
*   Version of webserv.c that includes some environment variables
*   when running CGI programs.
*
*   The variables included for cgi programs are:
*      SERVER_SOFTWARE
*      SERVER_NAME
*      REMOTE_PORT
*      REMOTE_ADDR
*      REQUEST_URI
*      REQUEST_METHOD
*      HTTP_USER_AGENT
*
*   This program uses the varlib.c system from the smsh.c
*   program in the shell Chapter.   That system does most
*   of the filing and export work for us.
*
*      usage: ws portnumber
*   features: supports the GET command only
*             runs in the current directory
*             forks a new child to handle each request
*             has MAJOR security holes, for demo purposes only
*             has many other weaknesses, but is a good start
*
*      build: cc sol12.5.c socklib.c varlib.c -o sol12.5
*
*      By showing how easily we can use varlib.c to manage the
*      variables for the web server, we see in concrete terms
*      how much a web browser work a shell and OS.

*/
#include	<stdio.h>
#include	<stdlib.h>
#include	<unistd.h>
#include	<fcntl.h>
#include	<sys/types.h>
#include	<sys/stat.h>
#include	<string.h>
#include	<sys/socket.h>
#include	<netinet/in.h>
#include	<arpa/inet.h>
#include	<errno.h>
#include	<time.h>
#include	<errno.h>

#include	"varlib.h"
#include	"socklib.h"

#define	oops(s,x) { perror(s); exit(x); }

void	setupvars();
void	process_request(int , struct sockaddr_in *);
void	process_header(FILE *);
void	act_on_request(char *, char *, int );
void	header( FILE *, char *);
void	cannot_do(int );
void	do_404(char *, int );
int	isadir(char *);
int	not_exist(char *);
void	do_ls(char *, int );
char	* file_type(char *);
int	ends_in_cgi(char *);
void	do_exec( char *, int );
void	do_cat(char *, int );

int main(int ac, char *av[])
{
int 		   sock, fd;
int		   len;
struct sockaddr_in clnt_addr;

if ( ac == 1 ){
fprintf(stderr,"usage: ws portnum\n");
exit(1);
}
sock = make_server_socket( atoi(av[1]) );
if ( sock == -1 )
oops("socket", 2);

setupvars();

/* main loop here */

while(1){
/*
* wait for a call
*/
len = sizeof(struct sockaddr);
fd = accept(sock, (struct sockaddr *)&clnt_addr, &len);

/*
* take a call and buffer it
*/
if ( fd >= 0 ){
process_request(fd, &clnt_addr);
close(fd);
}
else
perror("accept");
}
return 0;
}

/*
* load the environment table from environ and
* set some fixed values that describe this host and server
*/

void setupvars()
{
char	hostname[512];

VLstore("SERVER_SOFTWARE", "Simple-WebServer 0.2");
VLexport("SERVER_SOFTWARE");
gethostname(hostname, 512);
VLstore("SERVER_NAME", hostname);
VLexport("SERVER_NAME");
/*
add here other fixed values that can be
computed at startup
*/
}

/*
* A more general process_request than the earlier version
* This one has to read the header and put some parts into
* the environment list.
*/
void process_request(int fd, struct sockaddr_in *caller)
{
FILE	*fpin;
char	request[BUFSIZ];
char	portnumstr[10];
char	cmd[BUFSIZ], arg[BUFSIZ];

/* process the request in a child process */

if ( fork() != 0 )
return;

/* jot down the caller's adress and port */

VLstore("REMOTE_ADDR", inet_ntoa(caller->sin_addr));
VLexport("REMOTE_ADDR");
sprintf(portnumstr, "%d", ntohs(caller->sin_port));
VLstore("REMOTE_PORT", portnumstr);
VLexport("REMOTE_PORT");

/* buffer the socket for input and read request */

fpin = fdopen(fd, "r" );
if ( fpin == NULL )
exit(2);
fgets(request,BUFSIZ,fpin);
printf("got a call: request = %s", request);
process_header(fpin);

/* then do the request */

strcpy(arg, "./");
if ( sscanf(request,"%s%s", cmd, arg+2) == 2 ){
VLstore("REQUEST_METHOD", cmd);
VLexport("REQUEST_METHOD");
VLstore("REQUEST_URI",    arg+2);
VLexport("REQUEST_URI");
act_on_request(cmd, arg, fd);
}
}

/* ------------------------------------------------------ *
process_header(FILE *)
after the HTTP request may be several lines
of header information.  These variables provide
define the parameters of the request.
The set of parameters is terminated by a blank line.

This function looks for the header line marked

User-Agent: name-of-browser

And puts the value for that tag in the environment
under HTTP_USER_AGENT.  It's pretty easy to add other
http variables to the CGI environment.
------------------------------------------------------ */

void process_header(FILE *fp)
{
char	buf[BUFSIZ];
char	browser_tag[] = "User-Agent: ";
int	b_taglen = strlen(browser_tag);

while( fgets(buf,BUFSIZ,fp) != NULL && strcmp(buf,"\r\n") != 0 )
{
printf("Header line: %s", buf);
if ( strncmp(buf, browser_tag, b_taglen) == 0 )
{
VLstore("HTTP_USER_AGENT",buf+b_taglen);
VLexport("HTTP_USER_AGENT");
}
}
}
/* ------------------------------------------------------ *
act_on_request( char *cmd, char *arg, int fd )
do what the request asks for and write reply to fd
if the request is the HTTP command:  GET /foo/bar.html HTTP/1.0
then  cmd is "GET" and arg is "/foo/bar.html"
------------------------------------------------------ */

void act_on_request(char *cmd, char *arg, int fd)
{

if ( strcmp(cmd,"GET") != 0 )
cannot_do(fd);
else if ( not_exist( arg ) )
do_404(arg, fd );
else if ( isadir( arg ) )
do_ls( arg, fd );
else if ( ends_in_cgi( arg ) )
do_exec( arg, fd );
else
do_cat( arg, fd );
}

/* ------------------------------------------------------ *
the reply header thing: all functions need one
if content_type is NULL then don't send content type
------------------------------------------------------ */

void header( FILE *fp, char *content_type )
{
fprintf(fp, "HTTP/1.0 200 OK\r\n");
if ( content_type )
fprintf(fp, "Content-type: %s\r\nServer: Myhttpd/0.1\r\n", content_type );//这里有修改标记自己的server版本号
}

/* ------------------------------------------------------ *
simple functions first:
cannot_do(fd)       unimplemented HTTP command
and do_404(item,fd)     no such object
------------------------------------------------------ */

void cannot_do(int fd)
{
FILE	*fp = fdopen(fd,"w");

fprintf(fp, "HTTP/1.0 501 Not Implemented\r\n");
fprintf(fp, "Content-type: text/plain\r\n");
fprintf(fp, "\r\n");

fprintf(fp, "That command is not yet implemented\r\n");
fclose(fp);
}

void do_404(char *item, int fd)
{
FILE	*fp = fdopen(fd,"w");

fprintf(fp, "HTTP/1.0 404 Not Found\r\n");
fprintf(fp, "Content-type: text/plain\r\n");
fprintf(fp, "\r\n");

fprintf(fp, "The item you requested: %s\r\nis not found\r\n",
item);
fclose(fp);
}

/* ------------------------------------------------------ *
the directory listing section
isadir() uses stat, not_exist() uses stat
do_ls runs ls. It should not
------------------------------------------------------ */

int isadir(char *f)
{
struct stat info;
return ( stat(f, &info) != -1 && S_ISDIR(info.st_mode) );
}

int not_exist(char *f)
{
struct stat info;
return( stat(f,&info) == -1 );
}

void do_ls(char *dir, int fd)
{
FILE	*fp ;

fp = fdopen(fd,"w");
header(fp, "text/plain");
fprintf(fp,"\r\n");
fflush(fp);

dup2(fd,1);
dup2(fd,2);
close(fd);
execlp("ls","ls","-l",dir,NULL);
perror(dir);
exit(1);
}

/* ------------------------------------------------------ *
the cgi stuff.  function to check extension and
one to run the program.
------------------------------------------------------ */

char * file_type(char *f)
/* returns 'extension' of file */
{
char	*cp;
if ( (cp = strrchr(f, '.' )) != NULL )
return cp+1;
return "";
}

int ends_in_cgi(char *f)
{
return ( strcmp( file_type(f), "cgi" ) == 0 );
}

void do_exec( char *prog, int fd )
{
extern char **environ;
FILE	*fp ;

fp = fdopen(fd,"w");
header(fp, NULL);
fflush(fp);
dup2(fd, 1);
dup2(fd, 2);
close(fd);
environ = VLtable2environ();
execl(prog,prog,NULL);
perror(prog);
}
/* ------------------------------------------------------ *
do_cat(filename,fd)
sends back contents after a header
------------------------------------------------------ */

void do_cat(char *f, int fd)
{
char	*extension = file_type(f);
char	*content = "text/plain";
FILE	*fpsock, *fpfile;
int	c;

if ( strcmp(extension,"html") == 0 )
content = "text/html";
else if ( strcmp(extension, "gif") == 0 )
content = "image/gif";
else if ( strcmp(extension, "jpg") == 0 )
content = "image/jpeg";
else if ( strcmp(extension, "jpeg") == 0 )
content = "image/jpeg";

fpsock = fdopen(fd, "w");
fpfile = fopen( f , "r");
if ( fpsock != NULL && fpfile != NULL )
{
header( fpsock, content );
fprintf(fpsock, "\r\n");
while( (c = getc(fpfile) ) != EOF )
putc(c, fpsock);
fclose(fpfile);
fclose(fpsock);
}
exit(0);
}

/*
*	socklib.c
*
*	This file contains functions used lots when writing internet
*	client/server programs.  The two main functions here are:
*
*	make_server_socket( portnum )	returns a server socket
*					or -1 if error
*      make_server_socket_q(portnum,backlog)
*
*	connect_to_server(char *hostname, int portnum)
*					returns a connected socket
*					or -1 if error
*/

#include	<stdio.h>
#include	<stdlib.h>
#include	<unistd.h>
#include	<sys/types.h>
#include	<sys/socket.h>
#include	<netinet/in.h>
#include	<netdb.h>
#include	<time.h>
#include	<strings.h>
#include	<arpa/inet.h>

#define   HOSTLEN  256
#define	  BACKLOG  1

int make_server_socket_q(int , int );

int make_server_socket(int portnum)
{
return make_server_socket_q(portnum, BACKLOG);
}
int make_server_socket_q(int portnum, int backlog)
{
struct  sockaddr_in   saddr;   /* build our address here */
struct	hostent		*hp;   /* this is part of our    */
char	hostname[HOSTLEN];     /* address 	         */
int	sock_id;	       /* the socket             */

sock_id = socket(PF_INET, SOCK_STREAM, 0);  /* get a socket */
if ( sock_id == -1 )
return -1;

/** build address and bind it to socket **/

bzero((void *)&saddr, sizeof(saddr));   /* clear out struct     */
if ( gethostname(hostname, HOSTLEN) == -1 )   /* where am I ?   */
{
perror("gethostname");
exit(1);
}

hp = gethostbyname(hostname);           /* get info about host  */
if ( hp == NULL ){
perror("Cannot get host");
exit(2);
}
/* fill in host part    */
bcopy( (void *)hp->h_addr, (void *)&saddr.sin_addr, hp->h_length);
saddr.sin_port = htons(portnum);        /* fill in socket port  */
saddr.sin_family = AF_INET ;            /* fill in addr family  */
saddr.sin_addr.s_addr = INADDR_ANY;     /* 作为服务器，你要绑定【bind】到本地的IP地址上进行监听【listen】，
但是你的机器上可能有多块网卡，也就有多个IP地址，这时候你要选择绑定在哪个IP上面，如果指定为INADDR_ANY，那么系统将绑定默认的网卡【即IP地址】。
其中INADDR_ANY就是指定地址为0.0.0.0的地址,这个地址事实上表示不确定地址,或“所有地址”、“任意地址”。
INADDR_ANY,外部的client ask 从哪个server的地址进来都可以连接到80端口.*/
if ( bind(sock_id, (struct sockaddr *)&saddr, sizeof(saddr)) != 0 )
return -1;

/** arrange for incoming calls **/

if ( listen(sock_id, backlog) != 0 )
return -1;
return sock_id;
}

int connect_to_server(char *host, int portnum)
{
int sock;
struct sockaddr_in  servadd;        /* the number to call */
struct hostent      *hp;            /* used to get number */

/** Step 1: Get a socket **/

sock = socket( AF_INET, SOCK_STREAM, 0 );    /* get a line   */
if ( sock == -1 )
return -1;

/** Step 2: connect to server **/

bzero( &servadd, sizeof(servadd) );     /* zero the address     */
hp = gethostbyname( host );             /* lookup host's ip #   */
if (hp == NULL)
return -1;
bcopy(hp->h_addr, (struct sockaddr *)&servadd.sin_addr, hp->h_length);
servadd.sin_port = htons(portnum);      /* fill in port number  */
servadd.sin_family = AF_INET ;          /* fill in socket type  */

if ( connect(sock,(struct sockaddr *)&servadd, sizeof(servadd)) !=0)
return -1;

return sock;
}

注意需要加 saddr.sin_addr.s_addr = INADDR_ANY;不然只能用127.0.0.1不能用外网ip

/*
* header file for socklib
*	socklib.h

*/int make_server_socket_q(int , int );int make_server_socket(int );int connect_to_server(char *, int );

/* varlib.c
*
* a simple storage system to store name=value pairs
* with facility to mark items as part of the environment
*
* interface:
*     VLstore( name, value )    returns 1 for 0k, 0 for no
*     VLlookup( name )          returns string or NULL if not there
*     VLlist()			 prints out current table
*
* environment-related functions
*     VLexport( name )		 adds name to list of env vars
*     VLtable2environ()	 copy from table to environ
*     VLenviron2table()         copy from environ to table
*
* details:
*	the table is stored as an array of structs that
*	contain a flag for `global' and a single string of
*	the form name=value.  This allows EZ addition to the
*	environment.  It makes searching pretty easy, as
*	long as you search for "name="
*
*/

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

#define	MAXVARS	200		/* a linked list would be nicer */

struct var {
char *str;		/* name=val string	*/
int  global;		/* a boolean		*/
};

static struct var tab[MAXVARS];			/* the table	*/

static char *new_string( char *, char *);	/* private methods	*/
static struct var *find_item(char *, int);

int VLstore( char *name, char *val )
/*
* traverse list, if found, replace it, else add at end
* since there is no delete, a blank one is a free one
* return 1 if trouble, 0 if ok (like a command)
*/
{
struct var *itemp;
char	*s;
int	rv = 1;

/* find spot to put it              and make new string */
if ((itemp=find_item(name,1))!=NULL && (s=new_string(name,val))!=NULL)
{
if ( itemp->str )		/* has a val?	*/
free(itemp->str);	/* y: remove it	*/
itemp->str = s;
rv = 0;				/* ok! */
}
return rv;
}

char * new_string( char *name, char *val )
/*
* returns new string of form name=value or NULL on error
*/
{
char	*retval;

retval = malloc( strlen(name) + strlen(val) + 2 );
if ( retval != NULL )
sprintf(retval, "%s=%s", name, val );
return retval;
}

char * VLlookup( char *name )
/*
* returns value of var or empty string if not there
*/
{
struct var *itemp;

if ( (itemp = find_item(name,0)) != NULL )
return itemp->str + 1 + strlen(name);
return "";

}

int VLexport( char *name )
/*
* marks a var for export, adds it if not there
* returns 1 for no, 0 for ok
*/
{
struct var *itemp;
int	rv = 1;

if ( (itemp = find_item(name,0)) != NULL ){
itemp->global = 1;
rv = 0;
}
else if ( VLstore(name, "") == 1 )
rv = VLexport(name);
return rv;
}

static struct var * find_item( char *name , int first_blank )
/*
* searches table for an item
* returns ptr to struct or NULL if not found
* OR if (first_blank) then ptr to first blank one
*/
{
int	i;
int	len = strlen(name);
char	*s;

for( i = 0 ; i<MAXVARS && tab[i].str != NULL ; i++ )
{
s = tab[i].str;
if ( strncmp(s,name,len) == 0 && s[len] == '=' ){
return &tab[i];
}
}
if ( i < MAXVARS && first_blank )
return &tab[i];
return NULL;
}

void VLlist()
/*
* performs the shell's  `set'  command
* Lists the contents of the variable table, marking each
* exported variable with the symbol  '*'
*/
{
int	i;
for(i = 0 ; i<MAXVARS && tab[i].str != NULL ; i++ )
{
if ( tab[i].global )
printf("  * %s\n", tab[i].str);
else
printf("    %s\n", tab[i].str);
}
}

int VLenviron2table(char *env[])
/*
* initialize the variable table by loading array of strings
* return 1 for ok, 0 for not ok
*/
{
int     i;
char	*newstring;

for(i = 0 ; env[i] != NULL ; i++ )
{
if ( i == MAXVARS )
return 0;
newstring = malloc(1+strlen(env[i]));
if ( newstring == NULL )
return 0;
strcpy(newstring, env[i]);
tab[i].str = newstring;
tab[i].global = 1;
}
while( i < MAXVARS ){		/* I know we don't need this	*/
tab[i].str = NULL ;	/* static globals are nulled	*/
tab[i++].global = 0;	/* by default			*/
}
return 1;
}

char ** VLtable2environ()
/*
* build an array of pointers suitable for making a new environment
* note, you need to free() this when done to avoid memory leaks
*/
{
int	i,			/* index			*/
j,			/* another index		*/
n = 0;			/* counter			*/
char	**envtab;		/* array of pointers		*/

/*
* first, count the number of global variables
*/

for( i = 0 ; i<MAXVARS && tab[i].str != NULL ; i++ )
if ( tab[i].global == 1 )
n++;

/* then, allocate space for that many variables	*/
envtab = (char **) malloc( (n+1) * sizeof(char *) );
if ( envtab == NULL )
return NULL;

/* then, load the array with pointers		*/
for(i = 0, j = 0 ; i<MAXVARS && tab[i].str != NULL ; i++ )
if ( tab[i].global == 1 )
envtab[j++] = tab[i].str;
envtab[j] = NULL;
return envtab;
}

/*
* header for varlib.c package
* varlib.h
*/

int	VLenviron2table(char **);
int	VLexport(char *);
char	*VLlookup(char *);
void	VLlist();
int	VLstore( char *, char * );
char	**VLtable2environ();
int	VLenviron2table(char **);

#cc socklib.c varlib.c sol12.5.c -o sol1

#./sol1 80





参考：《Unix Linux编程实践教程》第12章