day = raw_input()
if day in ["Friday", "Saturday"]:
   print day, "is holiday"
else:
   print day, "is not a holiday"

name = raw_input()
if name in ["Rose", "Tulip", "Lily", "Daffodil"]:
   print name, "is a flower"
elif name in ["Mango", "Jackfruit", "Guava", "Papaya"]:
   print name, "is a fruit"
else:
   print "I don't know!"

while True:
   name = raw_input()
   if name == "Exit":
      break
   if name in ["Rose", "Tulip", "Lily", "Daffodil"]:
      print name, "is a flower"
   elif name in ["Mango", "Jackfruit", "Guava", "Papaya"]:
      print name, "is a fruit"
   else:
      print "I don't know!"

তাহলে শুরু হোক! আমি একটি একটি করে ব্লক দিব আর তার নিচে ওই ব্লক নিয়ে কথা বলব।

/*
 * Course Code 350
 *
 * A Multithreaded Tiny HTTP Server
 * Demonstrating Thread Pool Management
 * Following the Thread Pool Management
 * Outline from Unix Network Programming Vol 1
 * by W. Richard Stevens.
 *
 * Project accomplished by: Abu Mohammad Omar Shehab Uddin Ayub
 * Reg No. 2000 330 096
 * Section B
 * 3rd Year 2nd Semester
 * Dept of CSE, SUST
 *
 * Idea and guided by: Mahmud Shahriar Hussain
 * Lecturer
 * Dept of CSE, SUST
 *
 * Course Instructor: Rukhsana Tarannum Tazin
 * Lecturer
 * Dept of CSE, SUST
 */

#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#define MAX_CLIENT 5
#define MAX_THREAD 3
#define MAX_REQ_HEADER 10
#define MAX 10
#define MAX_LENGTH 6
#define MIME_LENGTH 20

typedef struct {
   pthread_t threadID;
   long threadCount;
}Thread;

typedef struct {
   char hostName[100];
   char filePath[100];
}Request;

typedef struct{
   int code;
   char date[30];
   char server[30];
   char last_modified[30];
   long content_length;
   char content_type[10];
   char file_path[80];
}Reply;

Thread thrdPool[MAX_THREAD];
Request request[MAX_THREAD];
Reply reply[MAX_THREAD];
int clntConnection[MAX_CLIENT], clntGet, clntPut;

thread_mutex_t clntMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t srvrMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t srvrMutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t emitMutex2 = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t clntCondition = PTHREAD_COND_INITIALIZER;

static int numThreads;

void *request_handler(void *arg);
int find_method (char *req);
Request parse_request(char *rbuff);
Reply prepare_reply(int code, Request rq);
char *getMimeType(char *str);
void emit_reply(int conn, Reply rply);

int main(void)
{

int i, serverSockfd, clientSockfd;
int serverLen, clientLen;
struct sockaddr_in serverAddress, clientAddress, tempAddress;

//defining number of threads
 numThreads = MAX_THREAD;

// initializing queue parameters
 clntGet = clntPut = 0;

//creating all the threads
for(i = 0; i < numThreads; i++)
{
    pthread_create(&thrdPool[i].threadID, NULL, &request_handler, (void *) i);
} // end of for loop

//creating the socket descriptor
serverSockfd = socket(AF_INET, SOCK_STREAM,0);

if(serverSockfd < 0)
{
   error("\nError opening socket");
   exit(1);
}

serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = INADDR_ANY;
serverAddress.sin_port = htons(80);
serverLen = sizeof(serverAddress);

if(bind(serverSockfd, (struct sockaddr *)&serverAddress, serverLen) < 0)
{
   printf("\nError in binding.");
   exit(1);
}

listen(serverSockfd, 10);

for( ; ; )
{
   fflush(stdout);
   //printf("\nWaiting for clients...");
   clientLen = sizeof(tempAddress);
   //printf("\n\nBlocked on accept()");
   clientSockfd = accept(serverSockfd, (struct sockaddr *)&clientAddress, &clientLen);
   //printf("\nAllocated client descriptor# %d", clientSockfd);
   pthread_mutex_lock(&srvrMutex);
   clntConnection[clntPut] = clientSockfd;
   if(++clntPut == MAX_CLIENT)
   clntPut = 0;

   if(clntPut == clntGet)
   {
      printf("\nCan't handle any more request...\nTerminating...");
      exit(1);
   }

   pthread_cond_signal(&clntCondition);
   pthread_mutex_unlock(&srvrMutex);
   fflush(stdout);

} // end of infinite for loop

} // end of main

void *request_handler(void *arg)
{

int connfd;
char *reqBuff;
fflush(stdout);
//printf("\nThread %d starting", (int) arg);

for( ; ; )
{
   pthread_mutex_lock(&clntMutex);
   //printf("\nMutex locked by thread# %d.", (int) arg);
   while(clntGet == clntPut)
   pthread_cond_wait(&clntCondition, &clntMutex);

connfd = clntConnection[clntGet];
if(++clntGet == MAX_CLIENT)
clntGet = 0;

// thread operation
// printf("\nIn between mutex lock-unlock. Thread# %d, Connection# %d", (int) arg, connfd);
reqBuff = (char *) malloc (1000);
read(connfd, reqBuff, 1000);

int temp;
temp = find_method(reqBuff);

if(temp == 0)
{
   //printf("\nfind_method returned 0");
   request[(int)arg] = parse_request(reqBuff);
   //printf("\nHost: %s\nFile Path: %s", request[(int)arg].hostName, request[(int)arg].filePath);
   reply[(int)arg] = prepare_reply(200, request[(int)arg]);
   printf("\n\nprinting the reply structure");
   //printf("\nCode: %d\nDate: %s\nServer: %s\nlast_modified: %s\ncontent_length: %ld\ncontent type: %s\nfile path: %s",   reply[(int)arg].code, reply[(int)arg].date, reply[(int)arg].server, reply[(int)arg].last_modified, reply[(int)arg].content_length, reply[(int)arg].content_type, reply[(int)arg].file_path);
   emit_reply(connfd, reply[(int)arg]);
}

else if(temp == 1)
{
   printf("\nfind_method returned 1");
   reply[(int)arg] = prepare_reply(501, request[(int)arg]);
   emit_reply(connfd, reply[(int)arg]);
}

else
{
   printf("\nfind_method returned -1");
   reply[(int)arg] = prepare_reply(400, request[(int)arg]);
   emit_reply(connfd, reply[(int)arg]);
}

pthread_mutex_unlock(&clntMutex);
//printf("\nMutex unlocked by thread# %d.", (int) arg);
thrdPool[(int) arg].threadCount++;

   // shahriar bhai told that closing the connection formally is not so important
   // good performance achieved @ closing it formally
   close(connfd);
}

} // end of request_handler function

void emit_reply(int conn, Reply rply)
{

//pthread_mutex_lock(&emitMutex2);
if(rply.code == 200)
{

char *ok_code = "HTTP/1.1 200 OK\r\n";
write(conn, ok_code, strlen(ok_code));

char *date;
date = (char *)malloc(100);
strcpy(date, "Date: ");
strcat(date, rply.date);
strcat(date, "\r\n");
write(conn, date, strlen(date));

char *server;
server = (char *)malloc(100);
strcpy(server, "Server: ");
strcat(server, rply.server);
strcat(server, "\r\n");
write(conn, server, strlen(server));

char *last_modified;
last_modified = (char *)malloc(100);
strcpy(last_modified, "Last-Modified: ");
strcat(last_modified, rply.last_modified);
strcat(last_modified, "\r\n");
write(conn, last_modified, strlen(last_modified));

char *content_length;
content_length = (char *)malloc(100);
strcpy(content_length, "Content-Length: ");
int decpnt, sign;
char *p;
p = (char *)malloc(20);
p = ecvt(rply.content_length, 15, &decpnt, &sign);
//printf("\nConversion-- %s %d %d", p, decpnt, sign);
 
strncat(content_length, p, decpnt);
strcat(content_length, "\r\n");
write(conn, content_length, strlen(content_length));

char *content_type;
content_type = (char *)malloc(100);
strcpy(content_type, "Content-Type: ");
strcat(content_type, rply.content_type);
strcat(content_type, "\r\n");
write(conn, content_type, strlen(content_type));

write(conn, "\r\n", 2);
 
int b;
char c;
FILE *fp;
fp = (FILE *) malloc(sizeof(FILE));
fp = fopen(rply.file_path, "rb");
while(!feof(fp))
{
   c = getc(fp);
   if(!feof(fp))
   {
      //printf("%c", c);
      write(conn, &c, 1);
   }
}

//pthread_mutex_unlock(&emitMutex2);
return;
}

else if(rply.code == 400)
{
   char *ok_code = "HTTP/1.1 400 Bad Request\r\n";
   write(conn, ok_code, strlen(ok_code));
   
   char *date;
   date = (char *)malloc(100);
   strcpy(date, "Date: ");
   strcat(date, rply.date);
   strcat(date, "\r\n");
   write(conn, date, strlen(date));
   char *server;
   server = (char *)malloc(100);
   strcpy(server, "Server: ");
   strcat(server, rply.server);
   strcat(server, "\r\n");
   write(conn, server, strlen(server));
   write(conn, "\r\n", 2);
   
   char *error_400;
   error_400 = (char *)malloc(300);
   strcpy(error_400, "<html><head><title>Error No: 400. Bad Request.</title></head><body><h2>The server cannot parse the request.</h2><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><hr>For further info mail to shehab_sust@yahoo.com.</body><html>");
   write(conn, error_400, strlen(error_400));
}

else if(rply.code == 501)
{
   char *ok_code = "HTTP/1.1 501 Method Not Implemented\r\n";
   write(conn, ok_code, strlen(ok_code));

   char *date;
   date = (char *)malloc(100);
   strcpy(date, "Date: ");
   strcat(date, rply.date);
   strcat(date, "\r\n");
   write(conn, date, strlen(date));

   char *server;
   server = (char *)malloc(100);
   strcpy(server, "Server: ");
   strcat(server, rply.server);
   strcat(server, "\r\n");
   write(conn, server, strlen(server));
   write(conn, "\r\n", 2);

   char *error_501;
   error_501 = (char *)malloc(300);
   strcpy(error_501, "<html><head><title>Error No: 501. Method Not Implemented.</title></head><body><h2>The server only resolves the GET method.</h2><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><hr>For further info mail to shehab_sust@yahoo.com.</body><html>");
   write(conn, error_501, strlen(error_501));
}

else if(rply.code == 404)
{
   char *ok_code = "HTTP/1.1 404 File Not Found\r\n";
   write(conn, ok_code, strlen(ok_code));
   
   char *date;
   date = (char *)malloc(100);
   strcpy(date, "Date: ");
   strcat(date, rply.date);
   strcat(date, "\r\n");
   write(conn, date, strlen(date));

   char *server;
   server = (char *)malloc(100);
   strcpy(server, "Server: ");
   strcat(server, rply.server);
   strcat(server, "\r\n");
   write(conn, server, strlen(server));
   
   write(conn, "\r\n", 2);

   char *error_404;
   error_404 = (char *)malloc(300);
   strcpy(error_404, "<html><head><title>Error No: 404. File Not Found.</title></head><body><h2>The server could not found the requested url.</h2><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><hr>For further info mail to shehab_sust@yahoo.com.</body><html>");
   write(conn, error_404, strlen(error_404));
}

else if(rply.code == 403)
{
   char *ok_code = "HTTP/1.1 403 Forbidden\r\n";
   write(conn, ok_code, strlen(ok_code));

   char *date;
   date = (char *)malloc(100);
   strcpy(date, "Date: ");
   strcat(date, rply.date);
   strcat(date, "\r\n");
   write(conn, date, strlen(date));

   char *server;
   server = (char *)malloc(100);
   strcpy(server, "Server: ");
   strcat(server, rply.server);
   strcat(server, "\r\n");
   write(conn, server, strlen(server));

   write(conn, "\r\n", 2);

   char *error_403;
   error_403 = (char *)malloc(300);
   strcpy(error_403, "<html><head><title>Error No: 403. Forbidden.</title></head><body><h2>You are not authorized to access this url.</h2><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><br><hr>For further info mail to shehab_sust@yahoo.com.</body><html>");
 
   write(conn, error_403, strlen(error_403));
}

} //end of emit_reply

char *getMimeType(char *str)
{
   printf("\nentered mime type");
   int i;
   //defined here the file extension
   char *fileExt[MAX];
   fileExt[0] = "html";
   fileExt[1] = "htm";
   fileExt[2] = "txt";
   fileExt[3] = "gif";
   fileExt[4] = "jpg";
   fileExt[5] = "qt";

   //defined here the mime type
   char *mType[MAX];
   mType[0] = "text/html";
   mType[1] = "text/html";
   mType[2] = "text/plain";
   mType[3] = "image/gif";
   mType[4] = "image/jpeg";
   mType[5] = "video/quicktime";

   for(i = 0; i < 6; i++)
   {
      if(strcmp(str, fileExt[i]) == 0)
      {
         printf("\nmatched");
         return mType[i];
      }
   } //end of for loop
   printf("\nreturning ERROR");
   char *er = "ERROR";
   return er;
} //end of getMimetype

Reply prepare_reply(int code, Request rq)
{

// extracting the file extension
char *drive, *direc, *fname, *ext;

drive = (char *) malloc (3);
direc = (char *) malloc (66);
fname = (char *) malloc (9);
ext = (char *) malloc (5);

Reply rpl;

if(code == 200)
{

rpl.code = 200;
 
time_t lt;
lt = time(NULL);
strcpy(rpl.date, ctime(&lt));
rpl.date[strlen(rpl.date) - 1] = '\0';
 
strcpy(rpl.server, "TinyThreadedServer/0.1a");

char dir[100];
getcwd(dir, 100);
//printf("\ncurrent dir is %s", dir);
//printf("\nfile path is %s", rq.filePath);
strcat(dir, "/");
strcat(dir, rq.filePath);
//printf("\nabsolute file path is %s", dir);
char *path, *p;
path = (char *) malloc (80);
p = (char *) malloc (80);
path = strtok(dir, "/");
strcpy(p, "/");
strcat(p, path);
do{
   path = strtok('\0', "/");
   if(path)
   {
      strcpy(ext, path);
      strcat(p, "/");
      strcat(p, path);
   }
} while(path);
//printf("\nthe c++ file path %s", p);

char *e;
e = (char *)malloc(10);
e = strtok(ext, ".");
e = strtok('\0', ".");
//printf("\nfile extension is %s", e);

FILE *fp;
fp = (FILE *) malloc(sizeof(FILE));
if((fp = fopen(p, "r")) == NULL)
{
   printf("\nFILE NOT FOUND.\nERROR CODE 404");
   rpl.code = 404;
   return rpl;
}

struct stat buff;
stat(p, &buff);
//printf("\nSize: %ld\ntime of last modification: %s", buff.st_size, ctime(&buff.st_mtime));

strcpy(rpl.last_modified, ctime(&buff.st_mtime));
rpl.last_modified[strlen(rpl.last_modified) - 1] = '\0';

rpl.content_length = buff.st_size;

if(strcmp(getMimeType(e), "ERROR") == 0)
{
   rpl.code = 403;
   fclose(fp);
   return rpl;
}

   strcpy(rpl.content_type, getMimeType(e));
   strcpy(rpl.file_path, p);
   fclose(fp);
}

else if (code == 400)
{
   rpl.code = 400;

   time_t lt;
   lt = time(NULL);
   strcpy(rpl.date, ctime(&lt));
   rpl.date[strlen(rpl.date) - 1] = '\0';

   strcpy(rpl.server, "TinyThreadedServer/0.1a");
}

else if (code == 501)
{
   rpl.code = 501;

   time_t lt;
   lt = time(NULL);
   strcpy(rpl.date, ctime(&lt));
   rpl.date[strlen(rpl.date) - 1] = '\0';
   
   strcpy(rpl.server, "TinyThreadedServer/0.1a");
}

   return rpl;
} //end of prepare_reply

Request parse_request(char *rbuff)
{
   char *fileName;
   char *hostName;
   int j, k, l, m, n;
   Request r;

fileName = (char *) malloc (100);
hostName = (char *) malloc (100);

for(j = 5, k = 0; ;j++, k++)
{
   if(rbuff[j] == ' ') break;
   fileName[k] = rbuff[j];
} //end of for loop
fileName[k]= '\0';
//printf("\nThe valid file path is %s", fileName);
strcpy(r.filePath, fileName);

//finding the host
char *p;
p = strstr(rbuff, "Host: ");

for(l = 0; l < 6; l++)
{
   p++;
} //end of for loop

for(m = 0, n = 0; ; m++, n++)
{
   if(*p == '\r' || *p == '\n') break;
   hostName[n] = *p;
   p++;
} //end of for loop
hostName[n]= '\0';

fflush(stdout);
strcpy(r.hostName, hostName);

   return r;
} // end of parse_request

int find_method (char *req)
{
   pthread_mutex_lock(&srvrMutex2);
   //printf("\nin the find_method function\n%s\nthe size of the request is: %d", req, strlen(req));

   char *method_list[6];
   method_list[0] = (char *) malloc (10);
   strcpy(method_list[0], "PUT");
   method_list[1] = (char *) malloc (10);
   strcpy(method_list[1], "HEAD");
   method_list[2] = (char *) malloc (10);
   strcpy(method_list[2], "POST");
   method_list[3] = (char *) malloc (10);
   strcpy(method_list[3], "DELETE");
   method_list[4] = (char *) malloc (10);
   strcpy(method_list[4], "TRACE");
   method_list[5] = (char *) malloc (10);
   strcpy(method_list[5], "CONNECT");
 
   int i, j = 0;
   char *r;
   r = (char *) malloc (10);
   for(i = 0; i < strlen(req); i++)
   {
      if(req[i] == ' ') break;
      r[i] = req[i];
   } //end of for loop
   r[i] = '\0';
   //printf("\nExtracted method is %s", r);

   if(strcmp(r, "GET") == 0)
   {
      //printf("\nit's a GET method !!!");
      pthread_mutex_unlock(&srvrMutex2);
      return 0;
   }
 
   for(i = 0; i < 7; i++)
   {
      if(strcmp(r, method_list[i]) == 0)
      {
         printf("\n%s matched with %s", r, method_list[i]);
         j = 1;
         break;
      }
   } //end of for loop

   if(j == 1)
   {
      pthread_mutex_unlock(&srvrMutex2);
      return 1;
   }
   else
   {
      pthread_mutex_unlock(&srvrMutex2);
      return -1;
   }
} // end of find_method