// 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; }