void signal_handler(int signum){ int err,i = 0; printf("I am the signal_handler of the Server\n"); flag = 1; pthread_cond_broadcast(&cond_empty); for(i=0;i<thread_pool_size;i++) /* Wait for all consumers termination */ if(err = pthread_join(*(cons + i),NULL)){ perror2("pthread_join",err); exit (1) ; } free(cons); if ( err = pthread_mutex_destroy(&mtx)){ perror2("pthread_mutex _destroy",err); exit(1); } if ( err = pthread_cond_destroy(&cond_empty)){ perror2("pthread_cond_ destroy",err); exit(1); } if ( err = pthread_cond_destroy(&cond_full)){ perror2("pthread_cond_ destroy",err); exit(1); } free(workQueue); printf("Server says:Adios muchachos!\n"); exit(EXIT_SUCCESS); }
long registerFile(char *filename , long owner) { //Counter for the index int i=0; //Store the error of mutex int err; //Store the fileid long tmpfileid=0; //Allocate memory for the new entry METADATA *entry = (METADATA *)malloc(sizeof(METADATA)); //Initialize gstring entry->filename = g_string_new(NULL); //Insert the filename the metadata table g_string_assign( entry->filename , g_strdup(filename)); //Insert create of the file in the metadata entry->owner = owner; //Lock strtok due to is not deadlock free if(err=pthread_mutex_lock(&lockerFileids)) { perror2("Failed to lock()",err); } //Increase counter for fileIds countFileIds +=1; //Copy fileid for consistence purpose tmpfileid = countFileIds; printf("Function registerFile: %ld\n" , countFileIds); //Store new client ID in the struct entry->fileid = tmpfileid; //Unloack Mutex if (err = pthread_mutex_unlock(&lockerFileids)) { perror2("Failed to lock()", err); } //insert new entry in client data table g_ptr_array_add(metadata, (gpointer) entry ); printf("entry fileid: %ld\n" , entry->fileid); //Return the new fileID for the file return entry->fileid; }
int decode(char *buf , FILEHEADER *header ) { //Store the thread error if exist int err; //Lock strtok due to is not deadlock free// if(err=pthread_mutex_lock(&locker)) { perror2("Failed to lock()",err); } //Use comma delimiter to find the type of //send message and retrieve the apropriate // fields// header->type=strdup(strtok(buf, ",")); if( strcmp(header->type , "REQCLIENTID" )== 0) { header->username=strdup(strtok(NULL,",")); header->MSGID = atol( strtok(NULL,",") ); } else if( strcmp(header->type , "REQCREATE" )== 0) { header->filename = strdup(strtok(NULL,",")); header->owner = atol( strtok(NULL,",")); header->MSGID = atol(strtok(NULL,",")); } else if( strcmp(header->type , "REQID" )== 0) { header->filename = strdup(strtok(NULL, ",")); } else if( strcmp(header->type , "REQFILEID" )== 0) { header->filename = strdup(strtok(NULL,",")); header->owner = atol( strtok(NULL,",")); header->MSGID = atol( strtok(NULL,",")); } else if( strcmp(header->type , "REQFILESLIST" )== 0) { header->MSGID = atol( strtok(NULL,",")); } //Unloack Mutex// if(err=pthread_mutex_unlock(&locker)) { perror2("Failed to lock()",err); } }
void *connection_handler(void *arg){ int err,length; char* directory; QNode* node; int newsock = ((information*)arg)->newsock; int queue_size = ((information*)arg)->queue_size; pthread_mutex_t *clientMutex = malloc(sizeof(pthread_mutex_t)); //--------------------------------------------- if ( err = pthread_detach(pthread_self())){ perror2("pthread_detach",err); exit(1); } pthread_mutex_init(clientMutex,NULL ) ; /* Initialize client mutex */ if (read_all(newsock,&length,sizeof(int)) != sizeof(int) ) perror_exit("read"); directory = malloc(length); if (read_all(newsock,directory,length) != length) perror_exit("read"); //print directory //printf("directory is: %s\n",directory); printf("[Thread: %ld]: About to scan directory Server\n",pthread_self()); fflush(stdout); findFiles(directory,newsock,queue_size,clientMutex); //create ack node = createQNode(); node->client_sock = newsock; node->buf = NULL; node->clientMutex = clientMutex; place(workQueue,node,queue_size); pthread_cond_broadcast(&cond_empty); pthread_exit(NULL); }
DWORD GetAccountSid( IN const WCHAR *accountName, IN const WCHAR *systemName, OUT SID **sid ) { SID_NAME_USE sidUsage; DWORD cbSid; DWORD cchReferencedDomainName = MAX_PATH; WCHAR referencedDomainName[MAX_PATH]; DWORD status; if (!accountName || !sid) return ERROR_INVALID_PARAMETER; cbSid = 0; *sid = NULL; if (!LookupAccountName( systemName, accountName, NULL, &cbSid, referencedDomainName, &cchReferencedDomainName, &sidUsage)) { status = GetLastError(); if (ERROR_INSUFFICIENT_BUFFER != status) { return perror("LookupAccountName"); } } *sid = LocalAlloc(LPTR, cbSid); if (*sid == NULL) { return perror("LocalAlloc"); } if (!LookupAccountName( systemName, accountName, *sid, &cbSid, referencedDomainName, &cchReferencedDomainName, &sidUsage)) { status = GetLastError(); LocalFree(*sid); return perror2(status, "LookupAccountName"); } return ERROR_SUCCESS; }
DWORD GetObjectSecurityDescriptorDacl( IN HANDLE object, OUT SECURITY_DESCRIPTOR **sd, OUT BOOL *daclPresent, OUT ACL **dacl ) { DWORD status; SECURITY_INFORMATION si; DWORD sizeNeeded; BOOL daclDefaulted; if (!sd || !daclPresent || !dacl) return ERROR_INVALID_PARAMETER; si = DACL_SECURITY_INFORMATION; if (!GetUserObjectSecurity( object, &si, NULL, 0, &sizeNeeded)) { status = GetLastError(); if (ERROR_INSUFFICIENT_BUFFER != status) { return perror("GetUserObjectSecurity"); } } *sd = LocalAlloc(LPTR, sizeNeeded); if (*sd == NULL) { return perror("LocalAlloc"); } if (!GetUserObjectSecurity( object, &si, *sd, sizeNeeded, &sizeNeeded)) { return perror("GetUserObjectSecurity"); } if (!GetSecurityDescriptorDacl(*sd, daclPresent, dacl, &daclDefaulted)) { status = GetLastError(); LocalFree(*sd); return perror2(status, "GetSecurityDescriptorDacl"); } return ERROR_SUCCESS; }
Graph* createTopNGraphs(int bucketsNumber,int bucketSize ,Graph *graph,Forum** _forum){ Graph* gforum; Graph* current=NULL,*prev; Graph* g; void* returnG; int i; int err; gforum = findGraph(graph,"forum"); int position = getEdgePos(gforum,"hasMember_person"); Node* node; Node *n; pthread_t creator[NUMBER_OF_TOP_N_FORUMS]; //Gia kathe topN forum xrhsimopoioume ena thread create_args args[NUMBER_OF_TOP_N_FORUMS]; for (i=0;i<NUMBER_OF_TOP_N_FORUMS;i++){ args[i].gforum = gforum; args[i].g = graph; args[i].forum = _forum[i]; if ( (err = pthread_create(&creator[i], 0, createForum, (void*)&args[i]))>0){ perror2("pthread_create",err); } } for (i=0;i<NUMBER_OF_TOP_N_FORUMS;i++){ //Anamonh na ftiaxtoun oi grafoi gia na tous sundesoume sthn lista grafwn if ( (err = pthread_join(creator[i],&returnG))>0){ perror2("pthread_join",err); } prev = current; current = (Graph*) returnG; if (i==0){ g = current; } else{ prev->next = current; } } return g; }
void* computeTopNForums(void* arg){ forum = (Forum**)malloc((NUMBER_OF_TOP_N_FORUMS)*sizeof(Forum*)); comp_args* args = (comp_args*) arg; Graph* graph = args->g; int N = args->n; int i,j; for (i=0;i<N;i++) forum[i]=NULL; int flag=0; Graph* gforum; gforum = findGraph(graph,"forum"); sort_args* arg_sort = (sort_args*)malloc(sizeof(sort_args)); int err; list_node* current = NULL ; i = -1; Node* node; pthread_t sorter[10]; pthread_mutex_init(&mtx_sort, 0); arg_sort->n = N; arg_sort->g = gforum; arg_sort->forum = forum; //Dhmiourgia 4 ergatwn-threads pou tha anazhtoun ta topN forums for (i=0;i<4;i++){ if ( (err = pthread_create(&sorter[i], 0, sortForums, (void*)arg_sort))>0){ perror2("pthread_create",err); } } //Anamonh na teliwsoun tis taxinomiseis for (i=0;i<4;i++){ if ( (err = pthread_join(sorter[i], 0))>0){ perror2("pthread_join",err); } } pthread_mutex_destroy(&mtx_sort); pthread_exit(forum); return forum; }
void *server(void *data) { data_struct *info = data; int port = info->port; pthread_t thr_server; int sock, newsock,retValue =-1; int optval; struct sockaddr_in server, client; socklen_t clientlen; struct sockaddr *serverptr=(struct sockaddr *)&server; struct sockaddr *clientptr=(struct sockaddr *)&client; struct hostent *rem; /* Create socket */ if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) perror_exit("socket"); server.sin_family = AF_INET; /* Internet domain */ server.sin_addr.s_addr = htonl(INADDR_ANY); server.sin_port = htons(port); /* The given port */ optval = 1;//make the socket reuseable fast setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval); /* Bind socket to address */ if (bind(sock, serverptr, sizeof(server)) < 0) perror_exit("bind"); /* Listen for connections */ if (listen(sock, 5) < 0) perror_exit("listen"); printf("Listening for connections to port %d\n", port); while (1) { clientlen = sizeof(client); /* accept connection */ if ((newsock = accept(sock, clientptr, &clientlen)) < 0) perror_exit("accept"); printf("Accepted connection\n"); info->socket = newsock; //thread pou tha eksyphrethsei thn aithsh retValue = pthread_create(&thr_server, NULL, thread_server, (void *)info); if(retValue == 1) perror2("pthread_create", retValue); //close(newsock); /* parent closes socket to client */ } }
int main(int argc , char *argv[]) { /***********************************************************************************/ /* LOCAL VARIABLES */ /***********************************************************************************/ //Store pthread ID pthread_t tid; //Store threads errors int err; int port; //Check of input arguments if(argc !=3) { printf("\nUsage: argv[0] -p [port]\n"); exit(-1); } //Initialize initialization(); //Retrieve input parameters port=atoi(argv[2]); printf("--------------------------------------\n"); printf("\nStarting File manager on port:%d ....\n" , port); printf("--------------------------------------\n"); // SIGINT is signal name create when Ctrl+c will pressed signal(SIGINT,signal_handler); //Handle segmentation corrupt signal(SIGSEGV, signal_handler); //Create a thread for the bind. if(err=pthread_create(&tid , NULL ,(void *) &bind_thread , (void *)(intptr_t)port)) { perror2("pthread_create", err); exit(1); } //Wait until all threads to finish. Normally Bind thread //is always running pthread_join(tid , (void *) 0); return 0; }//Main Function
static int connect_to_daemon(struct qdb_handle *qh) { WCHAR pipe_name[MAX_FILE_NAME]; ULONG status; if (qh->vmname && strcmp(qh->vmname, "dom0") != 0) { StringCbPrintf(pipe_name, sizeof(pipe_name), QDB_DAEMON_PATH_PATTERN, qh->vmname); } else { #ifdef BACKEND_VMM_wni /* on WNI we don't have separate namespace for each VM (all is in the * single system) */ DWORD user_name_len = UNLEN + 1; WCHAR user_name[user_name_len]; if (!GetUserName(user_name, &user_name_len)) { perror("GetUserName"); return 0; } StringCbPrintf(pipe_name, sizeof(pipe_name), QDB_DAEMON_LOCAL_PATH, user_name); #else StringCbPrintf(pipe_name, sizeof(pipe_name), QDB_DAEMON_LOCAL_PATH); #endif } qh->read_pipe = INVALID_HANDLE_VALUE; qh->write_pipe = INVALID_HANDLE_VALUE; status = QpsConnect(pipe_name, &qh->read_pipe, &qh->write_pipe); if (status != ERROR_SUCCESS) { perror2(status, "connect to server"); return 0; } return 1; }
void *serving_thread(void *argp) { char buffer[BUFSIZE]; char *clientip,*clientport; char *type,*data=NULL; int rval; int err; char *filename,*md5sum="xxx",*filesize="12324"; int socket = *(int*)argp; fileptr tempnode; FILE *fp; char prints[45]; printf("in thread:%d\n",socket); sprintf(prints,"../serverLog.%u",(unsigned int)pthread_self()); if ( (fp = fopen(prints,"wb")) == NULL ) { perror("fopen"); return NULL; } if (err=pthread_detach (pthread_self ())) { // Detach thread perror2("pthread_detach ",err); return NULL; } //////////////////////////////////////////////////////////////// if ((rval=myread(socket, buffer, BUFSIZE)) <= 0) { perror("read"); return NULL; } if ( GetType(buffer,fp) == JOINREQUEST) { parse_JoinRequest(buffer,&clientip,&clientport); JoinResponse(buffer); fprintf(fp,"JoinResponse to client with ip: %s\n",clientip); if(mywrite(socket,buffer,BUFSIZE) <= 0 ) { perror("write"); return NULL; } } while (runflag) { ///Ask FileList/// int rval; if ( (rval=myread(socket, buffer , BUFSIZE)) < 0) { perror("read"); break; } //an to socket exei kleisei else if ( rval == 0 ) { close(socket); break; } else if (GetType(buffer,fp) == ASKFILELIST) { //if (err = pthread_mutex_lock(&serverlist_mux) ){ // perror2(" pthread_mutex_lock ",err ); exit(1); } fprintf(fp,"upadate server's list\n"); initialize("./",&metadata); printf("initialization:\n"); printfile(metadata); //chekarw ti lista me ta arxeia pou diatiro kai gia kathe komvo tha ftiaxno 2 orismata pou tou //antistixoun filename kai md5 na mi ksexasw teleuteoorisma NULL FileList(buffer,metadata); fprintf(fp,"Send FileList to client with ip: %s\n",clientip); //if (err = pthread_mutex_unlock(&serverlist_mux) ){ // perror2(" pthread_mutex_unlock ",err ); exit(1); } if(mywrite(socket,buffer,BUFSIZE) <= 0 ) { perror("write"); break; } } ///AskFile/// else if (GetType(buffer,fp) == ASKFILE) { parse_AskFile(buffer,&filename); fprintf(fp,"client with ip: %s asked for file:%s\n",clientip,filename); //lock list gia anazitisi tou arxeiou if (err = pthread_mutex_lock(&serverlist_mux) ){ perror2(" pthread_mutex_lock ",err ); exit(1); } tempnode=filenode(metadata,filename,NULL); if (err = pthread_mutex_unlock(&serverlist_mux) ){ perror2(" pthread_mutex_unlock ",err ); exit(1); } AskFileResponse(buffer,filename,myip,myport); fprintf(fp,"server is going to send the file to client \n"); if(mywrite(socket,buffer,BUFSIZE) <= 0 ) { perror("write"); break; } } ///GetFile/// else if (GetType(buffer,fp) == GETFILE) { parse_GetFile(buffer,&filename,&md5sum); //stelnei to arxeio pou tou zita kai sti lista tou oti autos o client exei pleon to arxeio //lock list gia na ton prosthesei sti lista GetFileResponse(socket,filename,md5sum); if (err = pthread_mutex_lock(&serverlist_mux) ){ perror2(" pthread_mutex_lock ",err ); exit(1); } tempnode=filenode(metadata,filename,md5sum); add_peer(&tempnode,clientip,clientport); if (err = pthread_mutex_unlock(&serverlist_mux) ){ perror2(" pthread_mutex_unlock ",err ); exit(1); } fprintf(fp,"send File %s to client with ip: %s\n",filename,clientip); } ///SendFile else if (GetType(buffer,fp) == SENDFILE) { parse_SendFile(buffer,&filename,&md5sum,&filesize,socket); //lock list gia na prosthesei to arxeio if (err = pthread_mutex_lock(&serverlist_mux) ){ perror2(" pthread_mutex_lock ",err ); exit(1); } add_file(&metadata,filename,md5sum); tempnode=filenode(metadata,filename,md5sum); add_peer(&tempnode,clientip,clientport); if (err = pthread_mutex_unlock(&serverlist_mux) ){ perror2(" pthread_mutex_unlock ",err ); exit(1); } SendFileResponse(buffer,filename,md5sum); fprintf(fp,"new File %s from client with ip: %s\n",filename,clientip); if(mywrite(socket,buffer,BUFSIZE) <= 0 ) { perror("write"); break; } } ///DeleteFile else if (GetType(buffer,fp) == DELETEFILE) { printf("DeleteFile\n"); parse_DeleteFile(buffer,&filename,&md5sum); fprintf(fp,"File to delete: %s \n",filename); //lock list mux if (err = pthread_mutex_lock(&serverlist_mux) ){ perror2(" pthread_mutex_lock ",err ); exit(1); } tempnode=filenode(metadata,filename,NULL); if (err = pthread_mutex_unlock(&serverlist_mux) ){ perror2(" pthread_mutex_unlock ",err ); exit(1); } //lock file mux if (err = pthread_mutex_lock(&tempnode->file_mux) ){ perror2(" pthread_mutex_lock ",err ); exit(1); } if( remove(filename) != 0 ) perror( "Error deleting file" ); else printf("File %s successfully deleted\n",filename); if (err = pthread_mutex_unlock(&tempnode->file_mux) ){ perror2(" pthread_mutex_unlock ",err ); exit(1); } //lock list mux if (err = pthread_mutex_lock(&serverlist_mux) ){ perror2(" pthread_mutex_lock ",err ); exit(1); } delete_file(&metadata,filename,md5sum); if (err = pthread_mutex_unlock(&serverlist_mux) ){ perror2(" pthread_mutex_unlock ",err ); exit(1); } DeleteFileResponse(buffer,filename,md5sum); fprintf(fp,"file deleted %s\n",filename); if(mywrite(socket,buffer,BUFSIZE) <= 0 ) { perror("write"); break; } } } close(socket); fprintf(fp,"Closing connection.\n"); fclose(fp); free(argp); }
void *bind_thread(void *port) { int PORT=(intptr_t)port; //Socket descriptor for the Replica int sock; //Store Client socket. int newsock; //The size of the details for the accepted client int clientlen; struct sockaddr *clientPtr; struct sockaddr_in serv_addr; //Declare&Initialize sockaddr_in pointer for accept function struct sockaddr_in client_addr; struct sockaddr *servPtr; //for setsockopt to be possible to reuse the port int allow=1; //Store pthread ID pthread_t tid; //Store threads errors int err; /*Initialize socket structure */ serv_addr.sin_family=AF_INET; serv_addr.sin_addr.s_addr=htonl(INADDR_ANY); serv_addr.sin_port=htons((intptr_t)port); //Point to struct serv_addr. servPtr=(struct sockaddr *) &serv_addr; /*Create a socket and check if is created correct.*/ if((sock=socket(PF_INET,SOCK_STREAM,0)) < 0) { perror("Socket() failed"); exit(1); } //Allow to reuse the port if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &allow, sizeof(int)) == -1) { perror("\nsetsockopt\n"); close(sock); pthread_exit((void *) 0); } //Bind socket to address // if(bind(sock,servPtr, sizeof(serv_addr)) < 0) { perror("Bind() failed"); exit(1); } //Listen for connections // // MAXCLIENT. requests in queue// if(listen(sock , MAXCLIENT) < 0) { perror("Listen() failed"); exit(1); } printf("\n**************Start to listen to port:%d*******************\n" , PORT); //Accept connection from clients forever. while(1) { clientPtr=(struct sockaddr *) &client_addr; clientlen= sizeof(client_addr); if((newsock=accept(sock , clientPtr , &clientlen )) < 0) { perror("accept() failed"); exit(1); } if(err=pthread_create(&tid , NULL , &accept_thread , (void *) (intptr_t)newsock)) { perror2("pthread_create for accept_thread" , err); exit(1); } }//While(1) }
long registerClient(char *username) { //Counter for the index int i=0; //Store the error of mutex int err; //Check if the username exist in the data int isFound=0; //Pointer to the metadata CLIENT *point2client = NULL; //Check if the username exist in the array for(i=0; i < clidata->len; i++) { //Retrieve the data from the specific index point2client = ( CLIENT *) g_ptr_array_index(clidata ,i ); if(strcmp(username , point2client->username->str)==0) { //Indicate that username exist in the data isFound=1; //Stop the loop break; } } if(isFound==0) { //Allocate memory for the new entry CLIENT *entry = (CLIENT *)malloc(sizeof(CLIENT)); //Initialize gstring entry->username = g_string_new(NULL); //Insert the username the metadata table g_string_assign( entry->username , g_strdup(username)); //Lock strtok due to is not deadlock free if(err=pthread_mutex_lock(&lockercliCoun)) { perror2("Failed to lock()",err); } //Increase client ID countClientIds +=1; //Store new client ID in the struct entry->client_id = countClientIds; //Unloack Mutex if (err = pthread_mutex_unlock(&lockercliCoun)) { perror2("Failed to lock()", err); } //insert new entry in client data table g_ptr_array_add(clidata, (gpointer) entry ); return entry->client_id; } //If it found the client Id return it return point2client->client_id; }
// Open a window station and a desktop in another session, grant access to those handles DWORD GrantRemoteSessionDesktopAccess( IN DWORD sessionId, IN const WCHAR *accountName, IN WCHAR *systemName ) { DWORD status = ERROR_UNIDENTIFIED_ERROR; HRESULT hresult; HANDLE token = NULL; HANDLE tokenDuplicate = NULL; WCHAR fullPath[MAX_PATH + 1] = { 0 }; WCHAR arguments[UNLEN + 1]; PROCESS_INFORMATION pi = { 0 }; STARTUPINFO si = { 0 }; DWORD currentSessionId; if (!accountName) return ERROR_INVALID_PARAMETER; if (!ProcessIdToSessionId(GetCurrentProcessId(), ¤tSessionId)) { return perror("ProcessIdToSessionId"); } if (currentSessionId == sessionId) { // We're in the same session, no need to run an additional process. LogInfo("Already running in the specified session"); status = GrantDesktopAccess(accountName, systemName); if (ERROR_SUCCESS != status) perror2(status, "GrantDesktopAccess"); return status; } if (!OpenThreadToken(GetCurrentThread(), TOKEN_ALL_ACCESS, TRUE, &token)) { if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ALL_ACCESS, &token)) { return perror("OpenProcessToken"); } } if (!DuplicateTokenEx( token, MAXIMUM_ALLOWED, NULL, SecurityIdentification, TokenPrimary, &tokenDuplicate)) { status = perror("DuplicateTokenEx"); goto cleanup; } CloseHandle(token); token = tokenDuplicate; if (!SetTokenInformation(token, TokenSessionId, &sessionId, sizeof(sessionId))) { status = perror("SetTokenInformation"); goto cleanup; } if (!GetModuleFileName(NULL, fullPath, RTL_NUMBER_OF(fullPath) - 1)) { status = perror("GetModuleFileName"); goto cleanup; } hresult = StringCchPrintf(arguments, RTL_NUMBER_OF(arguments), L"\"%s\" -a %s", fullPath, accountName); if (FAILED(hresult)) { LogError("StringCchPrintf failed"); goto cleanup; } si.cb = sizeof(si); LogDebug("CreateProcessAsUser(%s)", arguments); if (!CreateProcessAsUser( token, fullPath, arguments, NULL, NULL, TRUE, // handles are inherited 0, NULL, NULL, &si, &pi)) { status = perror("CreateProcessAsUser"); goto cleanup; } status = WaitForSingleObject(pi.hProcess, 1000); if (WAIT_OBJECT_0 != status) { if (WAIT_TIMEOUT == status) { status = ERROR_ACCESS_DENIED; LogInfo("WaitForSingleObject timed out"); } else { status = perror("WaitForSingleObject"); } } cleanup: if (pi.hThread) CloseHandle(pi.hThread); if (pi.hProcess) CloseHandle(pi.hProcess); if (token) CloseHandle(token); return status; }
DWORD GrantDesktopAccess( IN const WCHAR *accountName, IN const WCHAR *systemName ) { HWINSTA originalWindowStation; HWINSTA windowStation = NULL; HDESK desktop = NULL; DWORD status = ERROR_UNIDENTIFIED_ERROR; SID *sid = NULL; EXPLICIT_ACCESS newEa[2]; if (!accountName) return ERROR_INVALID_PARAMETER; originalWindowStation = GetProcessWindowStation(); if (!originalWindowStation) { return perror("GetProcessWindowStation"); } windowStation = OpenWindowStation( L"WinSta0", FALSE, READ_CONTROL | WRITE_DAC); if (!windowStation) { return perror("OpenWindowStation"); } if (!SetProcessWindowStation(windowStation)) { status = perror("SetProcessWindowStation"); goto cleanup; } desktop = OpenDesktop( TEXT("Default"), 0, FALSE, READ_CONTROL | WRITE_DAC | DESKTOP_WRITEOBJECTS | DESKTOP_READOBJECTS); if (!desktop) { status = perror("OpenDesktop"); goto cleanup; } if (!SetProcessWindowStation(originalWindowStation)) { status = perror("SetProcessWindowStation(Original)"); goto cleanup; } status = GetAccountSid(accountName, systemName, &sid); if (ERROR_SUCCESS != status) { perror2(status, "GetAccountSid"); goto cleanup; } newEa[0].grfAccessPermissions = GENERIC_ACCESS; newEa[0].grfAccessMode = GRANT_ACCESS; newEa[0].grfInheritance = CONTAINER_INHERIT_ACE | INHERIT_ONLY_ACE | OBJECT_INHERIT_ACE; newEa[0].Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE; newEa[0].Trustee.TrusteeForm = TRUSTEE_IS_SID; newEa[0].Trustee.TrusteeType = TRUSTEE_IS_USER; newEa[0].Trustee.ptstrName = (WCHAR *)sid; newEa[1] = newEa[0]; newEa[1].grfAccessPermissions = WINSTA_ALL; newEa[1].grfInheritance = NO_PROPAGATE_INHERIT_ACE; status = MergeWithExistingDacl(windowStation, 2, newEa); if (ERROR_SUCCESS != status) { perror2(status, "MergeWithExistingDacl(WindowStation)"); goto cleanup; } newEa[0].grfAccessPermissions = DESKTOP_ALL; newEa[0].grfAccessMode = GRANT_ACCESS; newEa[0].grfInheritance = 0; status = MergeWithExistingDacl(desktop, 1, newEa); if (ERROR_SUCCESS != status) { perror2(status, "MergeWithExistingDacl(Desktop)"); goto cleanup; } cleanup: if (desktop) CloseDesktop(desktop); if (windowStation) CloseWindowStation(windowStation); if (sid) LocalFree(sid); return ERROR_SUCCESS; }
int main(void) { int i,err; pthread_t threads[THREADSNUM]; TopForumList* topForumList; Cpm** cpm; Gn **gn = NULL; //initialize poolList,mutex and conditionVariable poolList = createPoolList(); pthread_mutex_init(&mtx,0); pthread_cond_init(&cond_nonempty,0); //create THREADSNUM threads for(i=0;i<THREADSNUM;i++) if( (err = pthread_create(&threads[i],NULL,threadFunction,NULL))){ perror2("pthread_create",err); exit(1); } //load graph using files int bucketsNumber = 10; int bucketSize = 5; Graph* g = loadGraph(bucketsNumber, bucketSize); topForumList = PreperationFunction(g,NUMBER_OF_TOP_N_FORUMS); //printTopNForums(topForumList); int cliqueSize[2] = {3, 4}; cpm = computeCPMResults(g,cliqueSize,topForumList); validateCPMResults(cpm); double modularityMax = DBL_MAX; gn = computeGNResults(g,modularityMax,topForumList); validateGNResults(gn); free_memory(topForumList,cpm,gn);//free memory function /* Graph* g = createTempGraph(); EdgeList* edgeList = createEdgeList(); //find all GraphEdges findEdges(g,edgeList); //calculate communities of graph //printf("%d",DBL_MAX); double modularityMax = DBL_MAX; Community* communities = GirvanNewman(modularityMax,g,edgeList); for(int i=0;i<g->communitiesInfo->communitiesNum;i++){ for(int j=0;j<communities[i].numberOfGeneralMembers;j++) printf("member:%d\n",communities[i].generalMembers[j]); fflush(stdout); printf("\n"); } destroyGraph(g); */ //wait until all threads are done with their jobs for(i=0;i<THREADSNUM;i++) if( (err = pthread_join(threads[i],NULL)) ){ perror2("pthread_join",err); exit(1); } //destroy mutex and conditionVariable free(poolList); pthread_cond_destroy(&cond_nonempty); pthread_mutex_destroy(&mtx); return EXIT_SUCCESS; }
/* Main routine for the server threads */ thr_startfunc_t serve_pipe(void *data) { char sio_buf[BUFSIZ], sock_buf[BUFSIZ]; int fd_max, sio_fd, sock_fd; int sio_count, sock_count; int res, port; fd_set rfds, wfds; pipe_s *pipe = (pipe_s *)data; #if defined(__UNIX__) struct timeval tv = {pipe->timeout, 0}; struct timeval *ptv = &tv; #elif defined(__WIN32__) struct timeval tv = {0,10000}; struct timeval *ptv = &tv; DWORD msecs = 0, timeout = pipe->timeout * 1000; #endif port = pipe->sio.info.port; /* Only proceed if we can lock the mutex */ if (thr_mutex_trylock(pipe->mutex)) { error("server(%d) - resource is locked", port); } else { sio_count = 0; sock_count = 0; sio_fd = pipe->sio.fd; sock_fd = pipe->sock.fd; #if defined(__UNIX__) fd_max = sio_fd > sock_fd ? sio_fd : sock_fd; #elif defined(__WIN32__) fd_max = sock_fd; msecs = GetTickCount(); #endif fprintf(stderr, "server(%d) - thread started\n", port); while (1) { FD_ZERO(&rfds); FD_ZERO(&wfds); #if defined(__UNIX__) /* Always ask for read notification to check for EOF */ FD_SET(sio_fd, &rfds); /* Only ask for write notification if we have something to write */ if (sock_count > 0) FD_SET(sio_fd, &wfds); /* Reset timeout values */ tv.tv_sec = pipe->timeout; tv.tv_usec = 0; #endif /* Always ask for read notification to check for EOF */ FD_SET(sock_fd, &rfds); /* Only ask for write notification if we have something to write */ if (sio_count > 0) FD_SET(sock_fd, &wfds); //DBG_MSG2("server(%d) waiting for events", port); /* Wait for read/write events */ res = select(fd_max + 1, &rfds, &wfds, NULL, ptv); if (res == -1) { perror2("server(%d) - select()", port); break; } #if defined(__UNIX__) /* Use the select result for timeout detection */ if (res == 0) { fprintf(stderr, "server(%d) - timed out\n", port); break; } /* Input from serial port? */ if (FD_ISSET(sio_fd, &rfds)) #elif defined(__WIN32__) if (1) #endif { /* Only read input if buffer is empty */ if (sio_count == 0) { sio_count = sio_read(&pipe->sio, sio_buf, sizeof(sio_buf)); if (sio_count <= 0) { if (sio_count == 0) { #if defined(__UNIX__) fprintf(stderr, "server(%d) - EOF from sio\n", port); break; #endif } else { perror2("server(%d) - read(sio)", port); break; } } else { DBG_MSG3("server(%d) - read %d bytes from sio", port, sio_count); } } } /* Write to socket possible? */ if (FD_ISSET(sock_fd, &wfds)) { if (sio_count > 0) { if ((res = tcp_write(&pipe->sock, sio_buf, sio_count)) < 0) { perror2("server(%d) - write(sock)", port); break; } DBG_MSG3("server(%d) - Wrote %d bytes to sock", port, res); sio_count -= res; } } /* Input from socket? */ if (FD_ISSET(sock_fd, &rfds)) { /* Only read input if buffer is empty */ if (sock_count == 0) { sock_count = tcp_read(&pipe->sock, sock_buf, sizeof(sock_buf)); if (sock_count <= 0) { if (sock_count == 0) { fprintf(stderr, "server(%d) - EOF from sock\n", port); break; } else { perror2("server(%d) - read(sock)", port); break; } } DBG_MSG3("server(%d) - read %d bytes from sock", port, sock_count); } } #if defined(__UNIX__) /* Write to serial port possible? */ if (FD_ISSET(sio_fd, &wfds)) #elif defined(__WIN32__) /* No socket IO performed? */ if ((!FD_ISSET(sock_fd, &rfds)) && (!FD_ISSET(sock_fd, &wfds))) { /* Break on a time out */ if (GetTickCount() - msecs > timeout) { fprintf(stderr, "server(%d) - timed out\n", port); break; } } else { msecs = GetTickCount(); } if (1) #endif { if (sock_count > 0) { if ((res = sio_write(&pipe->sio, sock_buf, sock_count)) < 0) { perror2("server(%d) - write(sio)", port); break; } DBG_MSG3("server(%d) - wrote %d bytes to sio", port, res); sock_count -= res; } } } /* Unlock our mutex */ thr_mutex_unlock(pipe->mutex); } fprintf(stderr, "server(%d) exiting\n", port); /* Clean up - don't call pipe_cleanup() as that would nuke our mutex */ sio_cleanup(&pipe->sio); tcp_cleanup(&pipe->sock); free(pipe); thr_exit((thr_exitcode_t)0); return (thr_exitcode_t)0; }
void *consumer(void * ptr){ QNode* node; int dirlen,err; long pagesize = sysconf(_SC_PAGESIZE); //-------------------------------------------- while(1){ pthread_mutex_lock(&mtx);//protect data by locking the mutex while(workQueue->_size <= 0){ //printf(">>WorkQueue is empty\n"); pthread_cond_wait(&cond_empty,&mtx); if (flag == 1){ pthread_mutex_unlock(&mtx); printf("I am a consumer and i am ready to go!\n"); pthread_exit(NULL); } } node = workQueue->head; workQueue->head = node->next; if(workQueue->_size == 1) workQueue->last = node->next; workQueue->_size--; pthread_mutex_lock(node->clientMutex);//lock the client mute pthread_mutex_unlock(&mtx);//unlock the mutex pthread_cond_broadcast(&cond_full); //1) send the size of the path or ack if (node->buf == NULL) {//if this is the last package to a certain client dirlen = 0; //send ack printf("[Thread: %ld]: Received task:<ACK,%d>\n",pthread_self(),node->client_sock); fflush(stdout); } else dirlen = strlen(node->buf)+1; //send the size of the path if (write_all(node->client_sock,&dirlen,sizeof(int)) != sizeof(int)) perror_exit("write"); if (dirlen != 0){ //if this is not the last pack to a certain client printf("[Thread: %ld]: Received task:<%s,%d>\n",pthread_self(),node->buf,node->client_sock); fflush(stdout); // 2)send the path itself if (write_all(node->client_sock,node->buf,dirlen) != dirlen) perror_exit ("write"); // 3)send the size of the file if (write_all(node->client_sock,&node->sizeInBytes,sizeof(long)) != sizeof(long)) perror_exit("write"); // 4)send the pagesize if (write_all(node->client_sock,&pagesize,sizeof(long)) != sizeof(long)) perror_exit("write"); // 5)send the file itself printf("[Thread: %ld]: About to read file %s\n",pthread_self(),node->buf); fflush(stdout); writeFile(node,pagesize); pthread_mutex_unlock(node->clientMutex); free(node->buf); } else{//if this is the last package to a certain client close(node->client_sock); pthread_mutex_unlock(node->clientMutex); if ( err = pthread_mutex_destroy(node->clientMutex)){ perror2("pthread_mutex_destroy",err); exit(1); } free(node->clientMutex); } free(node); } }
int main(int argc, char *argv[]) { int port, sock, newsock; int err; int *temp; char workdir[50]; char prints[45]; pthread_t thr; int i; char *config; char title[30]; FILE *fp_config; socklen_t clientlen; struct sockaddr_in server, client; struct sockaddr *serverptr=(struct sockaddr *)&server; struct sockaddr *clientptr=(struct sockaddr *)&client; struct hostent *rem; static struct sigaction act; if (argc != 2) { printf("Please give <configuration file>\n"); return -1; } config=argv[1]; if ( (fp_config=fopen(config,"rb")) == NULL ) { perror("open config"); return -1; } for(i=0;i<3;i++) { if (i == 0){ fscanf(fp_config,"%s %s",title,workdir); printf("%s\n",workdir); } else if (i == 1){ fscanf(fp_config,"%s %s",title,myip); printf("%s\n",myip); } else if (i == 2){ fscanf(fp_config,"%s %s",title,myport); printf("%s\n",myport); } } fclose(fp_config); port = atoi(myport); act.sa_handler=handler; sigfillset(&(act.sa_mask)); sigaction(SIGPIPE,&act,NULL); sigaction(SIGINT,&act,NULL); pthread_mutex_init(&serverlist_mux,NULL); //init to mutex tis listas if ( chdir(workdir) < 0 ) //metavasi sto fakelo twn arxeiwn gia sugxronismo { perror("chdir"); return -1; } //dimiourgia socket if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror("socket"); return -1; } server.sin_family = AF_INET; /* Internet domain */ server.sin_addr.s_addr = inet_addr(myip); server.sin_port = htons(port); /* The given port */ //bind socket if (bind(sock, serverptr, sizeof(server)) < 0) { perror("bind"); return -1; } metadata=NULL; printf("going to initialize\n"); //arxikopoiisi listas prosthetontas osa arxeia exei o fakelos initialize("./",&metadata); printf("initialize over\n"); printfile(metadata); // Listen connections if (listen(sock, 5) < 0) { perror("listen"); return -1; } printf("Listening for connections to port %d\n", port); while (1) { temp=calloc(1,sizeof(int)); // accept connections if ( (newsock = accept(sock, clientptr, &clientlen)) < 0) { perror("accept"); return -1; } printf("newsock %d\n",newsock); *temp=newsock; if (err = pthread_create (&thr, NULL, serving_thread ,(void*)temp)) { /* New thread */ perror2("pthread_create ",err); return -1; } } close(sock); //destroy mutex if ( err = pthread_mutex_destroy(&serverlist_mux ) ) { /* Destroy mutex */ perror2 (" pthread_mutex_destroy", err); return -1; } }
int find_files(char* dirname, int socket, int *number, pthread_mutex_t *mtx) { int return_code, i, err; DIR *dir_ptr; struct dirent entry; struct dirent *result; struct stat mybuf; char buf[256]; if ((dir_ptr = opendir (dirname)) == NULL) { fprintf(stderr,"find files: couldn't open folder"); return -1; } else { while( ( return_code = readdir_r(dir_ptr, &entry, &result) ) == 0 && result!=NULL) { if (entry.d_ino==0) continue; if ( strcmp(entry.d_name,".")==0 || strcmp(entry.d_name,"..")==0) continue; strcpy(buf,dirname); strcat(buf,"/"); strcat(buf, entry.d_name); if ( stat (buf, & mybuf ) < 0) { perror ( buf ) ; continue ; } if (( mybuf.st_mode & S_IFMT ) == S_IFDIR ) // directory encountered { // printf("\ndirectory: %s\n", buf); if ( find_files(buf, socket, number, mtx) == -1) { fprintf(stderr,"find files recursion error"); return -1; } } else // file encountered { QueueNode *node; int filesize = (strlen(dirname)+strlen(entry.d_name)+2); node = create_node(); node->number = number; node->mutex = mtx; node->clientSock = socket; node->filesize = mybuf.st_size; node->mode = mybuf.st_mode; node->filename = malloc( filesize * sizeof(char) ); for (i=0; i<filesize; i++) node->filename[i] = '\0'; for (i=0; i<strlen(dirname); i++) node->filename[i] = dirname[i]; strcat(node->filename, "/"); strcat(node->filename, entry.d_name); node->filename_size = filesize-1; if (err = pthread_mutex_lock (& queue_lock )) { perror2 ("insert queue pthread_mutex_lock ", err ); exit (1); } while(size_queue(queue) == queue_size) { pthread_cond_wait ( &insert , &queue_lock ); } insert_queue(queue, node); pthread_cond_signal ( &worker_cond ); color_text(client_color); printf("[Client Thread: %ld]: Just added to queue: %s\n", pthread_self(), node->filename); if (err = pthread_mutex_unlock (& queue_lock )) { perror2 ("insernt queue pthread_mutex_unlock ", err ); exit (1) ; } // printf("file: %d, %s/%s\n", mybuf.st_size ,dirname, entry.d_name); } } closedir(dir_ptr); } return 0; }