int CLDEditTxtFile::LoadData() { if (TRUE == PathFileExists(m_strTxtFile)) { //_LoadTxtFileWithItems(m_arrFileItem); return _fgets(m_arrFileItem); } return 0; }
char * read_stdin1(int *stdin_size) { int input_size; char *temp = NULL; struct stat stat; fstat(fileno(input_file), &stat); input_size = stat.st_size; char *result = _malloc(input_size); do { assert(_fgets(result, input_size, input_file)); } while (strncmp(result, ">THREE", 6)); int read = 0; while (_fgets(result + read, input_size - read, input_file)) { int len = strlen(result + read); if (len == 0 || result[read] == '>') { break; } fprintf(stdout, "%s \n",result + read); read += len; if (result[read - 1] == '\n') { read--; } } result[read++] = '>'; result = realloc(result, read); *stdin_size = read; return result; }
char * fgets(char *s, int size, FILE * stream) { libc_func(fgets, char *, char *, int, FILE *); char *res; int len; res = _fgets(s, size, stream); if (res != NULL) { len = strlen(res); script_record_op('r', fileno(stream), s, len); } return res; }
char * fgets ( char * str, int num, FILE * stream ) { //printf("INTERCEPTED fgets\n"); clock_t start = clock(); char* ret = _fgets(str,num,stream); clock_t end = clock(); double called_time = (double)(start-program_start)/(double)(CLOCKS_PER_SEC); double exec_time = (double)(end-start)/(double)(CLOCKS_PER_SEC); fprintf(logFile,"%lf %lf fgets %s %d %p = %s\n",called_time,exec_time,str,num,stream,ret); return ret; }
int login() { char buff[20]; fprintf(FD, "R NAME %s\n", Robot.name); _fgets(buff, 20, FD); if (strcmp(buff, "S ERROR FULL") == 0) { debug printf("Arena is full, disconnect\n"); return FALSE; } else if (strcmp(buff, "S ERROR NAME") == 0) { debug printf("name not given or invalid, disconnect\n"); return FALSE; } else if (strcmp(buff, "S WAIT") == 0) { debug printf("Accepted, waiting for challenge\n"); return TRUE; } else { return FALSE; } }
static void script_start_record(int fd, const char *logname, const char *recording_path, enum script_record_format fmt) { FILE *log; struct script_record_info *srinfo; if (fd_map_get(&script_recorded_fds, fd, NULL)) { fprintf(stderr, "script_start_record: internal error: fd %i is already being recorded\n", fd); abort(); } log = fopen(logname, "a+"); if (log == NULL) { perror("umockdev: failed to open script record file"); exit(1); } /* if we have a previous record... */ fseek(log, 0, SEEK_END); if (ftell(log) > 0) { DBG(DBG_SCRIPT, "script_start_record: Appending to existing record of format %i for path %s\n", fmt, recording_path); /* ...and we're going to record the device name... */ if (recording_path) { /* ... ensure we're recording the same device... */ char *existing_device_path; char line[1000]; libc_func(fgets, char *, char *, int, FILE *); fseek(log, 0, SEEK_SET); while (_fgets(line, sizeof(line), log)) { switch (fmt) { case FMT_DEFAULT: /* Start by skipping any leading comments */ if (line[0] == '#') continue; if (sscanf(line, "d 0 %ms\n", &existing_device_path) == 1) { DBG(DBG_SCRIPT, "script_start_record: recording %s, existing device spec in record %s\n", recording_path, existing_device_path); /* We have an existing "d /dev/something" directive, check it matches */ if (strcmp(recording_path, existing_device_path) != 0) { fprintf(stderr, "umockdev: attempt to record two different devices to the same script recording\n"); exit(1); } free(existing_device_path); } // device specification must be on the first non-comment line break; case FMT_EVEMU: if (strncmp(line, "E: ", 3) == 0) break; if (sscanf(line, "# device %ms\n", &existing_device_path) == 1) { DBG(DBG_SCRIPT, "script_start_record evemu format: recording %s, existing device spec in record %s\n", recording_path, existing_device_path); /* We have an existing "/dev/something" directive, check it matches */ if (strcmp(recording_path, existing_device_path) != 0) { fprintf(stderr, "umockdev: attempt to record two different devices to the same evemu recording\n"); exit(1); } free(existing_device_path); } break; default: fprintf(stderr, "umockdev: unknown script format %i\n", fmt); abort(); } } fseek(log, 0, SEEK_END); } /* ...finally, make sure that we start a new line */ putc('\n', log); } else if (recording_path) { /* this is a new record, start by recording the device path */ DBG(DBG_SCRIPT, "script_start_record: Starting new record of format %i\n", fmt); switch (fmt) { case FMT_DEFAULT: fprintf(log, "d 0 %s\n", recording_path); break; case FMT_EVEMU: fprintf(log, "# EVEMU 1.2\n# device %s\n", recording_path); break; default: fprintf(stderr, "umockdev: unknown script format %i\n", fmt); abort(); } } srinfo = malloc(sizeof(struct script_record_info)); srinfo->log = log; assert(clock_gettime(CLOCK_MONOTONIC, &srinfo->time) == 0); srinfo->op = 0; srinfo->fmt = fmt; fd_map_add(&script_recorded_fds, fd, srinfo); }
/* Seq file should be like this: ; [Empty line or comment or id ...] [Empty line or sequence data] */ bool t_structure::verify_seq(char* seq_fp) { return(true); FILE* f_seq = open_f(seq_fp, "r"); char line_buffer[MAX_HEADER_LENGTH]; _fgets(line_buffer, MAX_HEADER_LENGTH, f_seq); // If the first character of first line is not semicolon, // this is not a valid sequence file. if(line_buffer[0] != ';') { printf("Verification failed for sequence file %s @ %s(%d)\n", seq_fp, __FILE__, __LINE__); return(false); } int current_line_cnt = 2; int i_seq = 0; char seq_data[MAX_HEADER_LENGTH]; // Read file and fill lines. while(1) { // Read next line starting with 2nd line. if(_fgets(line_buffer, MAX_HEADER_LENGTH, f_seq)) { //printf("Current line_buffer: %s\n", line_buffer); // If currently read line is after 2nd line // the sequence data is being retrieved. if(current_line_cnt > 2) { for(int i = 0; i < (int)strlen(line_buffer); i++) { // If this is end of sequence, if(seq_data[i_seq - 1] == '1') // Is sequence data already finished? { printf("Sequence data is ending before file ends, exiting at %s(%d)\n", __FILE__, __LINE__); return(false); } if(line_buffer[i] != '1' && line_buffer[i] != 'A' && line_buffer[i] != 'C' && line_buffer[i] != 'G' && line_buffer[i] != 'U' && line_buffer[i] != 'T' && line_buffer[i] != 'a' && line_buffer[i] != 'c' && line_buffer[i] != 'g' && line_buffer[i] != 'u' && line_buffer[i] != 't') { printf("Unknown nucleotide in sequence: %c, exiting at %s(%d)\n", line_buffer[i], __FILE__, __LINE__); return(false); } seq_data[i_seq++] = line_buffer[i]; } } current_line_cnt++; } else { break; } } // If 2nd line is not read OR no sequence data is read, // return false. /* if(current_line_cnt < 3 || // Check if at least 3 lines are read. i_seq == 0 || // Check if sequence data is read. seq_data[i_seq - 1] != '1') // Check correct ending of seq_data { printf("Verification failed for sequence file %s @ %s(%d)\n", seq_fp, __FILE__, __LINE__); return(false); } */ if(current_line_cnt < 3) // Check if at least 3 lines are read. { printf("Verification failed for sequence file %s @ %s(%d)\n", seq_fp, __FILE__, __LINE__); return(false); } if(i_seq == 0) // Check if sequence data is read. { printf("Verification failed for sequence file %s @ %s(%d): No sequence data\n", seq_fp, __FILE__, __LINE__); return(false); } if(seq_data[i_seq - 1] != '1') // Check correct ending of seq_data { printf("Verification failed for sequence file %s @ %s(%d): %c\n", seq_fp, __FILE__, __LINE__, seq_data[i_seq - 1]); return(false); } fclose(f_seq); return(true); }
int main(int argc,char *argv[]) { struct sockaddr_in server; int sock, port, err; char buff[2000]; if (argc != 3) { printf("Numero de argumentos invalido\n"); printf("Modo de uso:\n\n"); printf("\t robot [IP] [PORT]\n\n"); printf("\t IP: dirección ip del servidor. e.j. 127.0.0.1\n"); printf("\t PORT: número del puerto del servidor. e.j. 5600\n\n"); exit(-1); } sock = socket(PF_INET, SOCK_STREAM, 0); port = atoi(argv[2]); server.sin_family = AF_INET; server.sin_port = htons(port); server.sin_addr.s_addr = inet_addr(argv[1]); err = connect(sock, (struct sockaddr *)&server, sizeof(server)); if (err == -1) { printf("No se pudo establecer la conexión con el servidor\n"); exit(-1); } FD = fdopen(sock, "w+"); signal(SIGCONT, s_cont); if (pipe(pipeFD) == -1) { printf("Error al inicial el pipe. pipe() returned -1\n"); exit(-1); } setbuf(FD, NULL); initRobot(); buff[0] = '\0'; if (login() == FALSE) { printf("Error al iniciar la sesion\n"); fclose(FD); exit(-1); } CONTROLLER_ID = getpid(); ROBOT_ID = fork(); if (ROBOT_ID == -1) { printf("Error al iniciar, fork() returned -1\n"); exit(-1); } if (ROBOT_ID > 0) { signal(NTFY_ROBOT_PAUSE, pausedRobot); // CONTROLLER while (_fgets(buff, 2000, FD) != NULL) { debug printf("[Controller %d] msg from server: %s\n", getpid(), buff); if (strpos(buff, "S ACCEPTED") != -1) { kill(ROBOT_ID, S_ACCEPTED); } else if (strpos(buff, "S WIN") != -1) { kill(ROBOT_ID, S_WIN); break; } else if (strpos(buff, "S LOSE") != -1) { kill(ROBOT_ID, S_LOSE); break; } else if (strpos(buff, "S DRAW") != -1) { kill(ROBOT_ID, S_DRAW); break; } else if (strpos(buff, "S URTURN") != -1) { if (resumeRobot() == 0) { write(pipeFD[1], buff, strlen(buff) + 1); } debug printf("[Controller %d]: Durmiendo\n", getpid()); pause(); debug printf("[Controller %d]: Despertado\n", getpid()); } } kill(ROBOT_ID, SIGTERM); wait(ROBOT_ID); shutdown(sock, 2); fclose(FD); close(pipeFD[0]); close(pipeFD[1]); debug printf("## Fin del programa ##\n"); exit(0); } else if (ROBOT_ID == 0) { // ROBOT ROBOT_ID = getpid(); signal(S_ACCEPTED, s_accepted); signal(S_WIN, s_win); signal(S_LOSE, s_lose); signal(S_DRAW, s_draw); while(1) { // se bloquea a la espera del tubo doTurn(); } } }
char *fgets(char *s, int size, FILE *stream) { // Get libc syscall function pointer & offset in image libc_func(fgets, char *, char *, int, FILE *); if (plr_checkInsidePLR()) { // If already inside PLR code, just call original syscall & return return _fgets(s, size, stream); } else { plr_setInsidePLR(); int fn = fileno(stream); plrlog(LOG_SYSCALL, "[%d:fgets] Read line from fileno %d\n", getpid(), fn); syscallArgs_t args = { .addr = _off_fgets, .arg[0] = fn, .arg[1] = size }; plr_checkSyscallArgs(&args); // Nested function actually performed by master process only char *ret; fgetsShmData_t shmDat; int masterAct() { // Call original libc function ret = _fgets(s, size, stream); // Use ftell to get new file offset shmDat.err = errno; shmDat.retNull = (ret == NULL); shmDat.sLen = (ret == NULL) ? 0 : strlen(s)+1; shmDat.offs = ftell(stream); shmDat.eof = feof(stream); shmDat.ferr = ferror(stream); // Store return value & returned data in shared memory for slave processes plr_copyToShm(&shmDat, sizeof(shmDat), 0); if (!shmDat.retNull) { plr_copyToShm(s, shmDat.sLen, sizeof(shmDat)); } if (shmDat.ferr) { // Not sure how to handle passing ferror's to slaves yet, no way // to manually set error state plrlog(LOG_ERROR, "[%d:fgets] ERROR: ferror (%d) occurred (%d)\n", getpid(), shmDat.ferr, fn); exit(1); } return 0; } // All processes call plr_masterAction() to synchronize at this point plr_masterAction(masterAct); if (!plr_isMasterProcess()) { // Slaves copy return values from shared memory plr_copyFromShm(&shmDat, sizeof(shmDat), 0); if (!shmDat.retNull) { plr_copyFromShm(s, shmDat.sLen, sizeof(shmDat)); } // Slaves seek to new fd offset // Can't use SEEK_CUR and advance by ret because the slave processes // may have been forked from each other after the fd was opened, in which // case the fd & its offset are shared, and that would advance more than needed fseek(stream, shmDat.offs, SEEK_SET); // Necessary to manually reset EOF flag because fseek clears it if (shmDat.eof) { // fgetc at EOF to set feof indicator int c; if ((c = fgetc(stream)) != EOF) { const char *fmt = "[%d:fgets] ERROR: fgetc to cause EOF actually got data (%c %d), ftell = %d, feof = %d\n"; plrlog(LOG_ERROR, fmt, getpid(), c, c, ftell(stream), feof(stream)); exit(1); } } if (shmDat.ferr) { plrlog(LOG_ERROR, "[%d:fgets] ERROR: ferror (%d) from master (%d)\n", getpid(), shmDat.ferr, fn); exit(1); } } // TEMPORARY // Slave processes sometimes end up with the wrong file offset, even after SEEK_SET // Compare file state at exit to make sure everything is consistent // Piggybacking off checkSyscallArgs mechanism to do this syscallArgs_t exitState = { .arg[0] = ftell(stream), .arg[1] = feof(stream), .arg[2] = ferror(stream), }; plr_checkSyscallArgs(&exitState); // All procs return same value & errno ret = (shmDat.retNull) ? NULL : s; errno = shmDat.err; plr_clearInsidePLR(); return ret; }