// Macro is evil, inline function is more reliable.
static inline void insert_node(int level, void * bp) {
char **flist_head = get_head(level);
char **flist_tail = get_tail(level);
if (!(*flist_head)) {
// empty list
*flist_head = bp;
*flist_tail = bp;
set_prev_free(bp, NULL);
set_next_free(bp, NULL);
} else {
if ((char *)bp < (*flist_head)) {
// insert at head
set_prev_free(*flist_head, bp);
set_next_free(bp, *flist_head);
set_prev_free(bp, NULL);
*flist_head = bp;
} else if ((*flist_tail) < (char *)bp) {
// insert to tail
set_next_free(*flist_tail, bp);
set_prev_free(bp, *flist_tail);
set_next_free(bp, NULL);
*flist_tail = bp;
} else {
// find some place in the list
char * c = *flist_head;
while (c < (char *)bp) {
c = next_free(c);
}
set_next_free(prev_free(c), bp);
set_prev_free(bp, prev_free(c));
set_prev_free(c, bp);
set_next_free(bp, c);
}
}
}
static void print_selected(t_select **c_entry, t_select **m_entries)
{
char prev;
prev = 0;
if ((*c_entry)->selected && (prev = 1))
my_putstr((*c_entry)->entry);
next_free(c_entry);
while (*c_entry != *m_entries)
{
if ((*c_entry)->selected)
{
if (prev)
my_putchar(' ');
my_putstr((*c_entry)->entry);
prev = 1;
}
next_free(c_entry);
}
my_putchar('\n');
}
static inline void delete_node(int level, void * bp) {
char **flist_head = get_head(level);
char **flist_tail = get_tail(level);
if (bp == *flist_head) {
*flist_head = next_free(bp);
if (*flist_head) {
set_prev_free(*flist_head, NULL);
} else {
*flist_tail = NULL;
}
} else if (bp == *flist_tail) {
*flist_tail = prev_free(bp);
if (*flist_tail) {
set_next_free(*flist_tail, NULL);
} else {
*flist_head = NULL;
}
} else {
set_next_free(prev_free(bp), next_free(bp));
set_prev_free(next_free(bp), prev_free(bp));
}
}
/*
* find_fit - Find a fit for a block with asize bytes
*/
static void *find_fit(size_t asize){
/* First fit search */
void *bp;
char *flist_head;
int level = get_level(asize);
while (level < SEG_LEVLL) { // serach in the size-class from small to large
flist_head = *(get_head(level));
for (bp = flist_head; bp && GET_SIZE(HDRP(bp)) > 0; bp = next_free(bp)) {
if (asize <= GET_SIZE(HDRP(bp))) {
return bp;
}
}
level++;
}
return NULL; /* No fit */
}
static void printblock(void *bp)
{
size_t hsize, halloc;
hsize = GET_SIZE(HDRP(bp));
halloc = GET_ALLOC(HDRP(bp));
if (hsize == 0) {
printf("%p: EOL, prev_alloc: [%d]\n", bp, IS_PREV_ALLOC(HDRP(bp)));
return;
}
if (halloc){
printf("%p: header: [%u:%c], prev_alloc: [%d]\n",
bp, (unsigned)hsize, (halloc ? 'a' : 'f'), IS_PREV_ALLOC(HDRP(bp)));
} else {
printf("%p: header: [%u:%c], footer: [%u, %c], prev[%p], next[%p], prev_alloc: [%d]\n",
bp, (unsigned)hsize, (halloc ? 'a' : 'f'), GET_SIZE(FTRP(bp)), (GET_ALLOC(FTRP(bp)) ? 'a' : 'f'),
prev_free(bp), next_free(bp), IS_PREV_ALLOC(HDRP(bp)));
}
}
int main(void)
{
int listenfd;
int connfd;
client_t* head;/*to create new client and store in this structure */
struct sockaddr_in servaddr,cliaddr;
socklen_t clilen;
int next;/*next free index to be stored a client*/
broadcasrT* mes;
pthread_t brothread; /* broadcast thread to be start */
broad=0;
listenfd=0;
connfd=0;
/*initialize semaphores */
if(sem_init(&items,0,1))
{
printf("Could not initialize a semaphore\n");
return -1;
}
if(sem_init(&space,0,5))
{
printf("Could not initialize a semaphore\n");
return -1;
}
if(sem_init(&lock,0,1))
{
printf("Could not initialize a semaphore\n");
return -1;
}
if(sem_init(&signalB,0,0))
{
printf("Could not initialize a semaphore\n");
return -1;
}
if(sem_init(&enter,0,1))
{
printf("Could not initialize a semaphore\n");
return -1;
}
/*Use tcp*/
listenfd=socket(AF_INET,SOCK_STREAM,0);
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
/*listen to port 32000*/
servaddr.sin_port=htons(PORT);
bind(listenfd,(struct sockaddr *)&servaddr,sizeof(servaddr));
listen(listenfd,MAXCLIENTS);
clilen = sizeof(cliaddr);
signal(SIGINT,cleanup);
while (!quit)
{
pthread_t netthread;
connfd = accept(listenfd, (struct sockaddr *)&cliaddr, &clilen);
/*this semerphore is used to lock and unlock main thread */
sem_wait(&lock);
/*get next free index*/
next=next_free();
/*if next index is less than “currentThread” wont increate currentThread otherwise increase currentThread by one.*/
if(next<currectClient){
head=getClientDetails(next,connfd,netthread,cliaddr,clilen);
clients[next]=head;
}else{
head=getClientDetails(currectClient,connfd,netthread,cliaddr,clilen);
clients[currectClient]=head;
currectClient++;
}
/*unlock main thread*/
sem_post(&lock);
/* start broadcast thread and new thread for each connection.Here broadcast thread is initialize only one time that is done by “broad” variable */
if (broad==0)
{
/**/
mes=malloc(sizeof(broadcasrT));
mes->message=malloc(sizeof(char)*100);
strcpy(mes->message,"Broadcast thread has been started\n");
if( pthread_create( &brothread, NULL,broadcast_msg,(void*)mes)){
printf("error creating thread.");
abort();}
broad++;
}else{
}
if ( pthread_create( &netthread, NULL,handle_client,(void*)head) )
{
printf("error creating thread.");
abort();
}
}
close(listenfd);
free(clients[MAXCLIENTS]);
free(queue[MAX]);
return 0;
}
int main( void )
{
int* connfd;
struct sockaddr_in cliaddr;
socklen_t clilen;
pthread_t mythread;
int n, index;
char buffer[1000];
char* banner = "Hello This is the server Please enter your name: ";
char* banner2 = "SORRY....chat room is full, So you have to wait until you get the chance....\n ";
/* Install signal handler for SIGINT */
signal(SIGINT,cleanup);
listenfd = setup_server();
listen(listenfd,MAXCLIENTS);
clilen = sizeof(cliaddr);
/* Initialise any synchronisation variables like mutexes, attributes and memory */
while(!quit){
/* Accept an incoming connection */
connfd = malloc(sizeof(int));
*connfd = accept(listenfd, (struct sockaddr *) &cliaddr, &clilen);
/** find the next free index **/
index = next_free();
if(index == -1){
send(*connfd,banner2,strlen(banner2),0);
close(*connfd);
}
else{
send(*connfd,banner,strlen(banner),0);
n = recv(*connfd,buffer,MAXMSG,0);
buffer[n]=0;
/* Allocate and set up new client_t struct in clients array */
clients[index] = malloc(sizeof(client_t));
clients[index]->index = index;
clients[index]->sd = *connfd;
clients[index]->name = buffer;
/** threads are created here **/
if ( pthread_create( &mythread, NULL, handle_client, connfd) ){
printf("error creating thread.");
abort();
}
clients[index]->tid = mythread;
/* Create a DETACHED thread to handle the new client until the quit is set */
}
}
puts("Shutting down client connections...\n");
close(listenfd);
return 0;
}
/*
write data to file blocks on disk
*/
void write(char *filename, char *message){
int i, j;
//determine number of blocks needed
int block_num = ceil((double)strlen(message)/(double)B_SIZE);
//determine if num blocks free
if (block_num > 1 && sb.s_free < block_num){
printf("\nInsufficient free blocks.\n");
return;
}
//locate file
for(i = 0; i < NUM_INODES && strcmp(dir_table[current_dir][i].d_id, "\0") && strcmp(dir_table[current_dir][i].d_id, filename); i++);
unsigned long node_num = dir_table[current_dir][i].i_no;
//check access rights
struct inode inode = pool[node_num];
if( (inode.i_flags & WRITE) != WRITE ){
printf("\nYou do not have permission to write to this file.\n");
return;
}
//allocate blocks to inode
unsigned int indirect_blocks[block_num - NUM_DIRECT_BLOCKS]; //array of block numbers
if(block_num != (inode.i_size/B_SIZE) ){
sb.s_free -= block_num; sb.s_used += block_num;
struct fBlock info;
for(i = 0; i < NUM_DIRECT_BLOCKS && i < block_num; i++){
inode.i_data.direct[i].block = sb.s_first;
next_free();
}
if(block_num > NUM_DIRECT_BLOCKS){
inode.i_data.indirect.block = sb.s_first;
next_free();
for(i = 0; i < block_num - NUM_DIRECT_BLOCKS; i++){
indirect_blocks[i] = sb.s_first;
next_free();
}
//write indirect block to disk
fseek(disk, inode.i_data.indirect.block*B_SIZE, SEEK_SET);
fwrite(&indirect_blocks, sizeof(indirect_blocks), 1, disk);
fflush(disk);
}
}
//break data into B_SIZE chunks for writing
char bstr[block_num][B_SIZE];
for(i = 0; i < block_num; i++){
strncpy(bstr[i], &message[i*B_SIZE], B_SIZE);
}
//write bstr onto disk
for(i = 0; i < block_num; i++){
for(; i < NUM_DIRECT_BLOCKS && i < block_num; i++){
fseek(disk, inode.i_data.direct[i].block*B_SIZE, SEEK_SET);
fwrite(&bstr[i], B_SIZE, 1, disk);
fflush(disk);
}
for(j = 0; j < (block_num - NUM_DIRECT_BLOCKS); j++, i++){
fseek(disk, indirect_blocks[j]*B_SIZE, SEEK_SET);
fwrite(&bstr[j], B_SIZE, 1, disk);
fflush(disk);
}
}
//update modified date and dirty and size
time(&inode.modified);
inode.i_flags = (inode.i_flags | DIRTY);
inode.i_size = strlen(message);
//update inode in pool
pool[node_num] = inode;
printf("\nWrite successful\n");
return;
}
void create(char *filename, char type){
int i, j, k;
char c = IN_USE;
int x = IN_USE;
//find free inode: int i will determine position in bitmap
for(i = 0; (i < NUM_INODES) && ((c&x) == x); i++){
c = i_bmap[i]; x = 0x01; x = x<<7;
for(j = 0; j < 8 && ((c&x) == x); j++){
x = x>>1;
}
}
if(i == NUM_INODES && (c&x) == x){
printf("\nNo free inodes\n");
return;
}
//check for free block
unsigned int free_block = sb.s_first; //pointer to first free block
if (free_block == 0){
printf("\nNo free blocks\n");
return;
}
//mark in inode bitmap
i_bmap[i-1] = ( i_bmap[i-1] | x);
//fill in inode data values
struct inode inode;
inode.i_num = j; //inode number
inode.uid = 0x1234; //user id
inode.gid = 0x1234; //group id
inode.i_size = 0; //size of file in bytes
inode.i_flags = type | DIRTY | IN_USE; //Flags described above
time(&inode.creation); //creation date
time(&inode.modified); //modified date
inode.i_data.direct[0].block = free_block; //physical mapping
inode.parent_dir.i_no = current_dir;
//determine parent dir name
i = dir_table[current_dir][1].i_no;
if (i == -1){
strcpy(inode.parent_dir.d_id, "/");
}
else{
for(k = 0; k < NUM_INODES && strcmp(dir_table[i][k].d_id, "\0") && dir_table[i][k].i_no != current_dir; k++){;}
strcpy(inode.parent_dir.d_id, dir_table[i][k].d_id);
}
//set superblock free pointer to next block
next_free();
//store inode in pool
pool[j] = inode;
//create directory entry
for(k = 0; (k < NUM_INODES) && strcmp(dir_table[current_dir][k].d_id, "\0"); k++){;}
dir_table[current_dir][k].i_no = j;
strcpy(dir_table[current_dir][k].d_id, filename);
dir_table[current_dir][k+1].i_no = -1;
strcpy(dir_table[current_dir][k+1].d_id, "\0");
pool[current_dir].i_size += sizeof(struct directory);
if ( (type & DIRECTORY) == DIRECTORY){
//create directory in table
dir_table[j][0].i_no = inode.i_num;
strcpy(dir_table[j][0].d_id, ".");
dir_table[j][1].i_no = current_dir;
strcpy(dir_table[j][1].d_id, "..");
dir_table[j][2].i_no = -1;
strcpy(dir_table[j][2].d_id, "\0");
pool[j].i_size += sizeof(struct directory)*2;
}
printf("\nFile created\n");
return;
}
