int guiPlaylistInitialize(play_tree_t *my_playtree, m_config_t *config, int enqueue) { play_tree_iter_t *my_pt_iter = NULL; int result = 0; if(!mygui) guiInit(); if((my_pt_iter = pt_iter_create(&my_playtree, config))) { while ((filename = pt_iter_get_next_file(my_pt_iter)) != NULL) { if (parse_filename(filename, my_playtree, config, 0)) result = 1; else if (import_file_into_gui(filename, 0)) /* Add it to end of list */ result = 1; } } uiGotoTheNext = 1; if (result) { mygui->playlist->current = 0; uiSetFileName(NULL, mygui->playlist->tracks[0]->filename, STREAMTYPE_FILE); } if (enqueue) filename = NULL; return result; }
/* Creates a file named NAME with the given INITIAL_SIZE. Returns true if successful, false otherwise. Fails if a file named NAME already exists, or if internal memory allocation fails. */ bool filesys_create (const char *name, off_t initial_size, enum file_type type) { block_sector_t inode_sector = 0; char * parse = parse_filename (name); //get the correct dir struct dir *dir = dir_lookup_rec (parse); bool success = (dir != NULL && free_map_allocate (1, &inode_sector) && inode_create (inode_sector, initial_size, type) && dir_add (dir, parse, inode_sector)); if (!success && inode_sector != 0) free_map_release (inode_sector, 1); if( success == true && type == FILE_DIR ) { //we want to add . and .. as well if it is a dir //open the created directory struct file * created = filesys_open(parse); struct dir * mydir = dir_open(file_get_inode (created)); //add . to it dir_add (mydir, ".", inode_sector); struct inode * parent = dir_get_inode (dir); block_sector_t inode_sector_parent = inode_id(parent); //add .. to it dir_add (mydir, "..", inode_sector_parent); dir_close(mydir); file_close(created); } dir_close (dir); return success; }
void display_loadplaylistwindow(gui_t *gui) { OPENFILENAME playlistopen; char playlistfile[MAX_PATH]; memset(&playlistopen, 0, sizeof(OPENFILENAME)); memset(playlistfile, 0, sizeof(playlistfile)); playlistopen.lStructSize = sizeof(OPENFILENAME); playlistopen.hwndOwner = gui->mainwindow; playlistopen.hInstance = GetModuleHandle(NULL); playlistopen.lpstrFilter = "All Files (*.*)\0*.*\0" "Playlist Files (*.m3u;*.pls;*.txt)\0*.m3u;*.pls;*.txt\0"; playlistopen.nFilterIndex = 0; playlistopen.lpstrTitle = "Load Playlist..."; playlistopen.Flags = OFN_FILEMUSTEXIST | OFN_LONGNAMES | OFN_EXPLORER | OFN_READONLY | OFN_HIDEREADONLY; playlistopen.lpstrFile = playlistfile; playlistopen.lpstrCustomFilter = NULL; playlistopen.nMaxFile = MAXFILE; if(GetOpenFileName(&playlistopen)) { if(parse_filename(playlistfile, playtree, mconfig, 1)) gui->startplay(gui); } }
static size_t header_func(const void *ptr, size_t size, size_t nmemb, void *data) { (void)data; if (!file_name[0]) parse_filename((char*)ptr, size * nmemb); return size * nmemb; }
static mrb_bool parse_listcmd_args(mrb_state *mrb, mrdb_state *mrdb, listcmd_parser_state *st) { char *p; switch (mrdb->wcnt) { case 2: p = mrdb->words[1]; /* mrdb->words[1] ::= <lineno> | <filename> ':' <lineno> | <filename> */ if (!parse_lineno(mrb, &p, st)) { if (parse_filename(mrb, &p, st)) { if (skip_char(&p, ':')) { if (!parse_lineno(mrb, &p, st)) { st->parse_error = TRUE; } } } else { st->parse_error = TRUE; } } if (*p != '\0') { st->parse_error = TRUE; } break; case 1: case 0: /* do nothing */ break; default: st->parse_error = TRUE; printf("too many arguments\n"); break; } if (!st->parse_error) { if (!st->has_line_min) { st->line_min = (!st->filename && mrdb->dbg->prvline > 0) ? mrdb->dbg->prvline : 1; } if (!st->has_line_max) { st->line_max = st->line_min + 9; } if (st->filename == NULL) { if (mrdb->dbg->prvfile && strcmp(mrdb->dbg->prvfile, "-")) { st->filename = replace_ext(mrb, mrdb->dbg->prvfile, ".rb"); } } } if (st->parse_error || st->filename == NULL) { return FALSE; } return TRUE; }
static int parse_line( char* in, M3u_Playlist::entry_t& entry ) { int result = 0; // file entry.file = in; entry.type = ""; in = parse_filename( in, entry ); // track entry.track = -1; entry.decimal_track = 0; in = parse_track( in, entry, &result ); // name entry.name = in; in = parse_name( in ); // time entry.length = -1; in = parse_time( in, &entry.length, &result ); // loop entry.intro = -1; entry.loop = -1; if ( *in == '-' ) { entry.loop = entry.length; in++; } else { in = parse_time_( in, &entry.loop ); if ( entry.loop >= 0 ) { entry.intro = entry.length - entry.loop; if ( *in == '-' ) // trailing '-' means that intro length was specified { in++; entry.intro = entry.loop; entry.loop = entry.length - entry.intro; } } } in = next_field( in, &result ); // fade entry.fade = -1; in = parse_time( in, &entry.fade, &result ); // repeat entry.repeat = -1; in = parse_int( in, &entry.repeat, &result ); return result; }
int send_file_tcp(char *filepath, int socket_descriptor) { int totalBytesSent = 0; char buffer[BUFFER_SIZE]; FILE *fd; int file_size = fsize(filepath); int bytes_read; fd = fopen(filepath, "r"); if (fd == NULL || file_size < 1) return -1; // Send filename char *filename = parse_filename(filepath); strcpy(buffer, filename); send(socket_descriptor, buffer, BUFFER_SIZE, 0); free(filename); // Send file size itoa(file_size, buffer); send(socket_descriptor, buffer, BUFFER_SIZE, 0); // number of file data sending iterations between sending out-of-band data int oob_count = (file_size / BUFFER_SIZE) / 5; // Send file data int i = 0; // file data sending iterations counter while (1) { bytes_read = fread(buffer, sizeof(unsigned char), BUFFER_SIZE, fd); if (bytes_read <= 0) break; if (send(socket_descriptor, buffer, bytes_read, 0) == -1) { fclose(fd); return -1; } totalBytesSent += bytes_read; // Generate out-of-band data if (oob_count > 0 && ++i % oob_count == 0) { printf("sent %d bytes\n", totalBytesSent); if (send(socket_descriptor, "Z", 1, MSG_OOB) == -1) perror("send OOB error"); } if (bytes_read < BUFFER_SIZE) break; } printf("Total bytes sent: %d\n", totalBytesSent); fclose(fd); return 0; }
int guiPlaylist (int what, play_tree_t *playtree, m_config_t *config, int enqueue) { play_tree_iter_t *pt_iter = NULL; char *file; int added = FALSE; switch (what) { /* This function imports the initial playtree (based on cmd-line files) into the gui playlist by either: - overwriting gui pl (enqueue=0) */ case GUI_PLAYLIST_INIT: if(!mygui) guiInit(); if((pt_iter = pt_iter_create(&playtree, config))) { while ((file = pt_iter_get_next_file(pt_iter)) != NULL) { if (parse_filename(file, playtree, config, 0)) added = TRUE; else if (import_file_into_gui(file, 0)) /* Add it to end of list */ added = TRUE; } } guiInfo.PlaylistNext = TRUE; if (added) { mygui->playlist->current = 0; uiSetFile(NULL, mygui->playlist->tracks[0]->filename, STREAMTYPE_FILE); } if (enqueue) filename = NULL; break; /* This function imports and inserts an playtree, that is created "on the fly", for example by parsing some MOV-Reference-File; or by loading an playlist with "File Open" The file which contained the playlist is thereby replaced with it's contents. */ case GUI_PLAYLIST_ADD: if((pt_iter = pt_iter_create(&playtree, config))) { while ((file = pt_iter_get_next_file(pt_iter)) != NULL) if (import_file_into_gui(file, 1)) /* insert it into the list and set plCurrent = new item */ added = TRUE; pt_iter_destroy(&pt_iter); } break; } return added; }
/* Deletes the file named NAME. Returns true if successful, false on failure. Fails if no file named NAME exists, or if an internal memory allocation fails. */ bool filesys_remove (const char *name) { char * parse = parse_filename (name); //get the correct dir struct dir *dir = dir_lookup_rec (parse); bool success = dir != NULL && dir_remove (dir, parse); dir_close (dir); return success; }
/* * Parse a file path and return a structure containing its * components. * * This function takes a file path (e.g. /var/tmp/myexample.txt) * and produces a structure containing points to the path elements. * * typedef struct _PATHINFO_STRUCT { * char* fullpath; * char* filename; * char* dirpath; * char* extension; * int isdir; * } PATHINFO_STRUCT; * * The PATHINFO_STRUCT structure is allocated from the heap, as are * the strings pointed two by its members. This memory must be * returned to the heap by calling pathinfo_release, passing a pointer * to the PATHINFO_STRUCT returned by pathinfo_parse. */ PATHINFO_STRUCT* pathinfo_parse_filepath(const char* pathname) { DQHEADER deque; PATHINFO_STRUCT* pathinfop; char* pathdelim = "/"; char* pathbuff; char* tokenp = NULL; char* token_aheadp = NULL; int isdir = 0; // Get a pathinfo structure pathinfop = calloc(1, sizeof(PATHINFO_STRUCT)); pathinfop->fullpath = strdup(pathname); // Initialize a plenty big deque to hold path components. dq_init(strlen(pathname) + 1, sizeof(char), &deque); // Break the file path into tokens. Copy to a working buffer // so we don't alter path with calls to strtok pathbuff = strdup(pathname); // Check for leading / if (pathbuff[0] == '/') { push_token(&deque, "/"); } isdir = pathinfo_is_dir(pathname); pathinfop->isdir = isdir; // Get first token and look ahead token tokenp = strtok(pathbuff, pathdelim); token_aheadp = strtok(NULL, pathdelim); while (tokenp != NULL) { if (token_aheadp != NULL) { // More tokens in path string push_token(&deque, tokenp); push_token(&deque, "/"); tokenp = token_aheadp; token_aheadp = strtok(NULL, pathdelim); } else { // tokenp is the last token in the sequence if (!isdir) { parse_filename(pathinfop, tokenp); } else { push_token(&deque, tokenp); } tokenp = NULL; } } set_dirpath(pathinfop, &deque); free(pathbuff); return pathinfop; }
int send_file_udp(char *filepath, int socket_descriptor) { int totalBytesSent = 0; char buffer[BUFFER_SIZE]; FILE *fd; int file_size = fsize(filepath); int bytes_read; fd = fopen(filepath, "r"); if (fd == NULL || file_size < 1) return -1; // Send filename char *filename = parse_filename(filepath); strcpy(buffer, filename); send(socket_descriptor, buffer, BUFFER_SIZE, 0); free(filename); // Send file size itoa(file_size, buffer); send(socket_descriptor, buffer, BUFFER_SIZE, 0); // Send file data while (1) { bytes_read = fread(buffer, sizeof(unsigned char), BUFFER_SIZE, fd); if (bytes_read <= 0) break; if (send(socket_descriptor, buffer, bytes_read, 0) == -1) { fclose(fd); return -1; } // Wait reply if (recv(socket_descriptor, buffer, 1, 0) < 1) { fclose(fd); return -1; } totalBytesSent += bytes_read; printf("%d bytes sent\n", totalBytesSent); } printf("Total bytes sent: %d\n", totalBytesSent); fclose(fd); return 0; }
/* Opens the file with the given NAME. Returns the new file if successful or a null pointer otherwise. Fails if no file named NAME exists, or if an internal memory allocation fails. */ struct file * filesys_open (const char *name) { char * parse = parse_filename (name); //get the correct dir struct dir *dir = dir_lookup_rec (parse); struct inode *inode = NULL; if (dir != NULL) dir_lookup (dir, parse, &inode); dir_close (dir); return file_open (inode); }
/** Match the same underlying file, and device files with the same name. */ static Bool blobdata_file_same(const OBJECT *newo, const OBJECT *cached) { FILELIST *newflptr ; HQASSERT(newo && cached, "Objects missing for file comparison") ; HQASSERT(oType(*newo) == OFILE, "Blob data source is not a file") ; HQASSERT(oType(*cached) == OFILE || oType(*cached) == OSTRING, "Blob data source is not a file or a filename") ; newflptr = oFile(*newo) ; HQASSERT(newflptr, "No filelist in file object") ; /* Object identity has already been checked. The file is the same if: 1) The file pointers are the same 2) The file names and devices of the files are the same 3) The file name and device of the new file match a filename */ if ( oType(*cached) == OFILE ) { FILELIST *oldflptr = oFile(*cached) ; if ( oldflptr == newflptr ) return TRUE ; if ( theIDeviceList(oldflptr) != NULL && theIDeviceList(oldflptr) == theIDeviceList(newflptr) && HqMemCmp(theICList(oldflptr), theINLen(oldflptr), theICList(newflptr), theINLen(newflptr)) == 0 ) return TRUE ; } else if ( oType(*cached) == OSTRING ) { if ( theIDeviceList(newflptr) != NULL ) { uint8 *filename, *devicename ; /* file_open stores the filename in a FILELIST as a C-string (zero terminated), so we can use strcmp to compare it. */ if ( parse_filename(oString(*cached), theLen(*cached), &devicename, &filename) == DEVICEANDFILE && strcmp((const char *)theIDevName(theIDeviceList(newflptr)), (const char *)devicename) == 0 && strcmp((const char *)theICList(newflptr), (const char *)filename) == 0 ) return TRUE ; } } return FALSE ; }
/* * Parse the given string and find the bootloader file name, load address and * entry point information then call set_bootloader function. * * @param context The main context pointer * @param token The parse token value * @param rest String to parse * @return 0 and 1 for success and failure */ static int parse_bootloader(build_image_context *context, parse_token token, char *rest) { char filename[MAX_BUFFER]; char e_state[MAX_STR_LEN]; u_int32_t load_addr; u_int32_t entry_point; assert(context != NULL); assert(rest != NULL); if (context->generate_bct != 0) return 0; /* Parse the file name. */ rest = parse_filename(rest, filename, MAX_BUFFER); if (rest == NULL) return 1; PARSE_COMMA(1); /* Parse the load address. */ rest = parse_u32(rest, &load_addr); if (rest == NULL) return 1; PARSE_COMMA(1); /* Parse the entry point. */ rest = parse_u32(rest, &entry_point); if (rest == NULL) return 1; PARSE_COMMA(1); /* Parse the end state. */ rest = parse_end_state(rest, e_state, MAX_STR_LEN); if (rest == NULL) return 1; if (strncmp(e_state, "Complete", strlen("Complete"))) return 1; /* Parsing has finished - set the bootloader */ return set_bootloader(context, filename, load_addr, entry_point); }
/* * Parse the given string and find the bct file name. * * @param context The main context pointer * @param token The parse token value * @param rest String to parse * @return 0 and 1 for success and failure */ static int parse_bct_file(build_image_context *context, parse_token token, char *rest) { char filename[MAX_BUFFER]; assert(context != NULL); assert(rest != NULL); /* Parse the file name. */ rest = parse_filename(rest, filename, MAX_BUFFER); if (rest == NULL) return 1; /* Parsing has finished - set the bctfile */ context->bct_filename = filename; /* Read the bct file to buffer */ read_bct_file(context); update_context(context); return 0; }
void filename_input_function ( ui_object *obj, void *arg ) { char *text; text = get_ui_object_text (save_filename_input); if (text) { if (strlen (text) > 0) { parse_filename (text, FILENAME_MAX_LENGTH); set_ui_object_text (save_current_filename, text); } } set_ui_object_drawable (save_current_filename, TRUE); set_ui_object_drawable (save_filename_input, FALSE); }
static void notify_save_file_list (ui_object *obj, void *arg) { char *text; text = get_ui_object_text (obj); if (text) { if (strlen (text) > 0) { parse_filename (text, FILENAME_MAX_LENGTH); set_ui_object_text (save_current_filename, text); } } set_ui_object_drawable (save_current_filename, TRUE); set_ui_object_drawable (save_filename_input, FALSE); }
int info_process(s_audinfo_t *inf) { int ret = 0; int filetype; /* misc check */ filetype = parse_filename(inf->fnamei, strlen(inf->fnamei)); Log("%d", filetype); /* parse file */ switch (filetype) { case FILE_RAW: case FILE_PCM: Log("raw data, can not parse"); ret = 0; break; case FILE_WAV: ret = parsewav(inf); break; case FILE_MP3: ret = parsemp3(inf); break; case FILE_AAC: ret = parseaac(inf); break; case FILE_AMR: ret = parseamr(inf); break; case FILE_AWB: ret = parseawb(inf); break; default: Loge("Unsupported file type"); break; } return ret; }
size_t tool_header_cb(void *ptr, size_t size, size_t nmemb, void *userdata) { struct OutStruct *outs = userdata; const char *str = ptr; const size_t cb = size * nmemb; const char *end = (char*)ptr + cb; /* * Once that libcurl has called back tool_header_cb() the returned value * is checked against the amount that was intended to be written, if * it does not match then it fails with CURLE_WRITE_ERROR. So at this * point returning a value different from sz*nmemb indicates failure. */ size_t failure = (size * nmemb) ? 0 : 1; if(!outs->config) return failure; #ifdef DEBUGBUILD if(size * nmemb > (size_t)CURL_MAX_HTTP_HEADER) { warnf(outs->config, "Header data exceeds single call write limit!\n"); return failure; } #endif if((cb > 20) && checkprefix("Content-disposition:", str)) { const char *p = str + 20; /* look for the 'filename=' parameter (encoded filenames (*=) are not supported) */ for(;;) { char *filename; size_t len; while(*p && (p < end) && !ISALPHA(*p)) p++; if(p > end - 9) break; if(memcmp(p, "filename=", 9)) { /* no match, find next parameter */ while((p < end) && (*p != ';')) p++; continue; } p += 9; /* this expression below typecasts 'cb' only to avoid warning: signed and unsigned type in conditional expression */ len = (ssize_t)cb - (p - str); filename = parse_filename(p, len); if(filename) { outs->filename = filename; outs->alloc_filename = TRUE; outs->s_isreg = TRUE; outs->fopened = FALSE; outs->stream = NULL; break; } else return failure; } } return cb; }
/* Starts running the client in given mode, parameters: struct hostent *hostname - host information int port - port used by client char *filename - file to be uploaded / downloaded Return 0 if successful. */ int runServer(int port) { int returnval = 0, t_sock = 0, filecheck = 0, rv = 0, sockSrv = 0, stopping = 0; packet *pck = NULL; init_packet *i_pck = NULL; error_packet *e_pck = NULL; clientnode *first_cl = NULL, *temp_cl = NULL; filedata *files = NULL; char *filename = NULL; char buffer[TFTP_BLOCK]; fd_set srv_fd_set; struct timeval to; /* Create socket */ if((sockSrv = socket(AF_INET,SOCK_DGRAM,0)) < 0) error("Error creating socket"); /* Set own address data */ own_address.sin_family = AF_INET; own_address.sin_addr.s_addr = htons(INADDR_ANY); own_address.sin_port = htons(port); addr_length = sizeof(struct sockaddr_in); /* Bind socket to own address */ if(bind(sockSrv,(struct sockaddr *)&own_address,addr_length) < 0) { error("Port probably in use, select another port.\nUsage:\t./server <port>\n\nError in socket binding"); } while(1) { FD_ZERO(&srv_fd_set); to.tv_sec = 0; to.tv_usec = 1; FD_SET(0,&srv_fd_set); /* If server is set to stop and wait for current connections to finish, stop listening the server socket */ if(stopping == 0) FD_SET(sockSrv,&srv_fd_set); rv = select(sockSrv+1,&srv_fd_set,NULL,NULL,&to); if (rv < 0) error("Error in select()"); else if(rv > 0) { /* Adding a client */ if(FD_ISSET(sockSrv,&srv_fd_set)) { /* Get packet */ pck = read_packet(sockSrv); printf("New connection from: %s:%d. ",(char *)inet_ntoa(get_conn_addr().sin_addr), ntohs(get_conn_addr().sin_port)); /* Create new socket */ if((t_sock = socket(AF_INET,SOCK_DGRAM,0)) < 0) perror("Error creating socket"); /* Set port and try to bind */ transfer_address.sin_family = AF_INET; transfer_address.sin_addr.s_addr = htons(INADDR_ANY); transfer_address.sin_port = htons(create_port(1)); while(bind(t_sock,(struct sockaddr *)&transfer_address,addr_length) < 0) { transfer_address.sin_port = htons(create_port(0)); } printf("Bound to port: %d. ",ntohs(transfer_address.sin_port)); /* Check packet size */ if((pck->length < 10) || (pck->length > MAX_MSG)) { pck = encode_error_packet(ERROR_ILLEGAL_OPERATION); printf("\nInvalid init packet size\n"); send_packet(t_sock,pck); close(t_sock); } else { i_pck = decode_init_packet(pck); /* If client wants to read a file */ if(ntohs(i_pck->opcode) == OPCODE_RRQ) { /* File name from packet */ filename = parse_filename(i_pck->content); printf("Requesting file \"%s\".\n",filename); first_cl = add_client(first_cl,get_conn_addr(),t_sock,filename,OPCODE_RRQ,files); if(read_file_to_block(first_cl) == -1) { pck = encode_error_packet(ERROR_NOT_FOUND); send_packet(t_sock,pck); first_cl->state = STOP; } } /* If client wants to write a file */ else if (ntohs(i_pck->opcode) == OPCODE_WRQ) { /* File name from packet */ filename = parse_filename(i_pck->content); printf("Sending file \"%s\".\n",filename); /* Check that it can be written */ if((filecheck = check_file(filename)) != 0) { pck = encode_error_packet(filecheck); send_packet(t_sock,pck); close(t_sock); } else { first_cl = add_client(first_cl,get_conn_addr(),t_sock,filename,OPCODE_WRQ,NULL); } } /* Error */ else if (ntohs(i_pck->opcode) == OPCODE_ERROR) { e_pck = decode_error_packet(pck); printf("Error from client: %s\n",e_pck->content); close(t_sock); } /* Else illegal operation */ else { pck = encode_error_packet(ERROR_ILLEGAL_OPERATION); send_packet(t_sock,pck); printf("Invalid opcode\n"); close(t_sock); } } } /* If something is typed into stdin */ if(FD_ISSET(0,&srv_fd_set)) { bzero(&buffer,TFTP_BLOCK); fgets(buffer,TFTP_BLOCK-1,stdin); /* Closing ? */ if(strcasecmp(buffer,"CLOSE\n") == 0) stopping = 1; } } temp_cl = first_cl; /* Go through clients */ while(temp_cl != NULL) { /* If not set as stopped */ if(temp_cl->state != STOP) { /* Set address info */ set_conn_addr(temp_cl->address); switch(temp_cl->mode) { case OPCODE_RRQ: upload_mode(temp_cl); break; case OPCODE_WRQ: /* If there was some error while downloading from client - try to remove the file */ if(download_mode(temp_cl) != 1) { printf("Error happened. Trying to remove unfinished file ... "); if(close(temp_cl->filed) == 0) { temp_cl->filed = -1; if(!remove(temp_cl->filename)) printf("file \"%s\" was removed.\n",temp_cl->filename); else printf("file \"%s\" cannot be removed.\n",temp_cl->filename); } } break; default: break; } } temp_cl = temp_cl->next; } /* Remove stopped clients */ first_cl = remove_stopped(first_cl); if((stopping == 1) && (first_cl == NULL)) { printf("Server stopping\n"); break; } } close(sockSrv); return returnval;
int display_openfilewindow(gui_t *gui, int add) { OPENFILENAME fileopen; int result = 0; char filelist[MAXFILE]; char filename[MAX_PATH]; char directory[MAX_PATH]; char *filespec = NULL; char *filepart = NULL; memset(&fileopen, 0, sizeof(OPENFILENAME)); memset(filelist, 0, sizeof(filelist)); fileopen.lStructSize = sizeof(OPENFILENAME); fileopen.hwndOwner = gui->mainwindow; fileopen.hInstance = GetModuleHandle(NULL); fileopen.lpstrFilter = "All Files (*.*)\0*.*\0" "Media Files (*.avi;*.asf;*.wmv;*.mpg;*.mpeg;*.m2v;*.mov;\ *.rmvb;*.rm;*.ogm;*.mp3;*.wav;*.wma;*.ra;*.ogg)\0\ *.avi;*.asf;*.wmv;*.mpg;*.mpeg;*.m2v;*.mov;\ *.rmvb;*.rm;*.ogm;*.mp3;*.wav;*.wma;*.ra;*.ogg\0" "Video Files (*.avi;*.mpg;*.mpeg;*.mov)\0*.avi;*.mpg;*.mpeg;*.mov\0" "Avisynth Scripts (*.avs)\0*.avs\0" "Audio Files (*.mp3;*.wav;*.ra)\0*.mp3;*.wav;*.ra\000"; fileopen.nFilterIndex = 0; fileopen.lpstrTitle = "Add file(s)..."; fileopen.Flags = OFN_ALLOWMULTISELECT | OFN_FILEMUSTEXIST| OFN_LONGNAMES | OFN_EXPLORER| OFN_READONLY | OFN_HIDEREADONLY; fileopen.lpstrFile = filelist; fileopen.lpstrCustomFilter = NULL; fileopen.nMaxFile = MAXFILE; if(GetOpenFileName(&fileopen)) { /* clear playlist */ if(!add) gui->playlist->clear_playlist(gui->playlist); memcpy(directory, fileopen.lpstrFile, fileopen.nFileOffset - 1); directory[fileopen.nFileOffset - 1] = 0; do { filespec = &fileopen.lpstrFile[fileopen.nFileOffset]; filename[0] = 0; strcat(filename, directory); strcat(filename, "\\"); strcat(filename, filespec); if (GetFileAttributes(filename) & FILE_ATTRIBUTE_DIRECTORY) mp_msg(MSGT_GPLAYER, MSGL_V, "[GUI] %s is a directory, skipping...\n", filename); else { if (GetFullPathName(filename, MAX_PATH, filename, &filepart)) { mplSetFileName(NULL, filename, STREAMTYPE_FILE); if(!parse_filename(filename, playtree, mconfig, 0)) gui->playlist->add_track(gui->playlist, filename, NULL, filepart, 0); mp_msg(MSGT_GPLAYER, MSGL_V, "[GUI] Adding file: %s - path %s\n", filespec, filename); result++; } } fileopen.nFileOffset += strlen(filespec) + 1; } while (*filespec); } return result; }
static LRESULT CALLBACK PlayListWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { HWND wdg; POINT cursor; gui_t *gui = (gui_t *) GetWindowLongPtr(hwnd, GWLP_USERDATA); playlist_t *pl = gui ? gui->playlist : NULL; switch (iMsg) { case WM_CREATE: { wdg = CreateWindow("button", "Play", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 4, 10, 80, 25, hwnd, (HMENU) ID_PLAY, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0); wdg = CreateWindow ("button", "Up", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 4, 37, 80, 25, hwnd, (HMENU) ID_UP, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT,(WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0); wdg = CreateWindow ("button", "Down", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 4, 64, 80, 25, hwnd, (HMENU) ID_DOWN, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT),0); wdg = CreateWindow ("button", "Remove", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 4, 91, 80, 25, hwnd, (HMENU) ID_REMOVE, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT),0); wdg = CreateWindow ("button", "Load", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 4, 118, 80, 25, hwnd, (HMENU) ID_PLAYLISTLOAD, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT),0); wdg = CreateWindow ("button", "Save", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 4, 145, 80, 25, hwnd, (HMENU) ID_PLAYLISTSAVE, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT),0); wdg = CreateWindow ("button", "Close", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 4, 193, 80, 25, hwnd, (HMENU) ID_CLOSE, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT),0); wdg = CreateWindow ("listbox", "tracklist", WS_CHILD | WS_VISIBLE | LBS_NOTIFY | WS_VSCROLL | WS_HSCROLL | LBS_DISABLENOSCROLL, 92, 10, 300, 208, hwnd, (HMENU) ID_TRACKLIST, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0); SendMessage(wdg, LB_SETHORIZONTALEXTENT, MAX_PATH*4, 0); break; } case WM_CONTEXTMENU: { GetCursorPos(&cursor); SetForegroundWindow(hwnd); TrackPopupMenu(gui->playlistmenu, 0, cursor.x, cursor.y, 0, hwnd, NULL); break; } case WM_COMMAND: { int selected = 0; int i; for (i=0; i<pl->trackcount; i++) if(0 < SendDlgItemMessage(hwnd, ID_TRACKLIST, LB_GETSEL, i, 0)) selected = i + 1; switch (LOWORD(wParam)) { case ID_CLOSE: DestroyWindow(hwnd); return 0; case ID_TRACKLIST: if(HIWORD(wParam) == LBN_DBLCLK) { case ID_PLAY: if(selected) pl->current = selected - 1; mplSetFileName(NULL, pl->tracks[pl->current]->filename, STREAMTYPE_STREAM); gui->startplay(gui); } return 0; case ID_UP: { if(selected) pl->moveup_track(pl, selected); selected--; break; } case ID_DOWN: { if(selected) pl->movedown_track(pl, selected); selected++; break; } case ID_REMOVE: if(selected) pl->remove_track(pl, selected); break; case ID_ADDFILE: { if(guiIntfStruct.StreamType == STREAMTYPE_DVD || guiIntfStruct.StreamType == STREAMTYPE_DVDNAV) return 0; display_openfilewindow(gui, 1); break; } case ID_ADDURL: { if(guiIntfStruct.StreamType == STREAMTYPE_DVD || guiIntfStruct.StreamType == STREAMTYPE_DVDNAV) return 0; display_openurlwindow(gui, 1); break; } case ID_CLEAR: { if(!gui->playlist->trackcount) return 0; gui->playlist->clear_playlist(gui->playlist); break; } case ID_PLAYLISTLOAD: { if(guiIntfStruct.StreamType == STREAMTYPE_DVD || guiIntfStruct.StreamType == STREAMTYPE_DVDNAV) return 0; display_loadplaylistwindow(gui); break; } case ID_PLAYLISTSAVE: { /* no point saving an empty playlist */ if(!gui->playlist->trackcount || guiIntfStruct.StreamType == STREAMTYPE_DVD || guiIntfStruct.StreamType == STREAMTYPE_DVDNAV) return 0; display_saveplaylistwindow(gui); break; } } updatetracklist(hwnd); if(selected < 1) selected = 1; else if(selected>pl->trackcount) selected = pl->trackcount; SendDlgItemMessage(hwnd, ID_TRACKLIST, LB_SETCURSEL, selected - 1, 0); return 0; } case WM_DROPFILES: { char file[MAX_PATH]; int filecount = DragQueryFile((HDROP) wParam, -1, file, MAX_PATH); int i; for (i=0; i<filecount; i++) { DragQueryFile((HDROP) wParam, i, file, MAX_PATH); if(!parse_filename(file, playtree, mconfig, 0)) pl->add_track(pl, file, NULL, NULL, 0); } DragFinish((HDROP) wParam); updatetracklist(hwnd); } break; } return DefWindowProc(hwnd, iMsg, wParam, lParam); }
static LRESULT CALLBACK OpenUrlWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam) { static HWND url; HWND wdg; FILE *f; char *history = get_path("gui.url"); gui_t *gui = (gui_t *) GetWindowLongPtr(hwnd, GWLP_USERDATA); switch (iMsg) { case WM_CREATE: wdg = CreateWindow("button", "Ok", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 4, 43, 80, 25, hwnd, (HMENU) ID_OK, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0); wdg = CreateWindow("button", "Cancel", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, 90, 43, 80, 25, hwnd, (HMENU) ID_CANCEL, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0); url = wdg = CreateWindowEx(WS_EX_CLIENTEDGE, "edit", NULL, WS_CHILD | WS_VISIBLE | ES_LEFT | ES_AUTOHSCROLL, 4, 10, 300, 25, hwnd, (HMENU) ID_URL, ((LPCREATESTRUCT) lParam) -> hInstance, NULL); SendMessage(wdg, WM_SETFONT, (WPARAM) GetStockObject(DEFAULT_GUI_FONT), 0); SendMessage(wdg, EM_SETLIMITTEXT, MAX_PATH, 0); /*subclass the edit box to capture the VK_RETURN key*/ OldUrlWndProc = (WNDPROC)SetWindowLongPtr(url, GWLP_WNDPROC, (LONG_PTR)SubUrlWndProc); if((f = fopen(history, "r"))) { char lasturl[MAX_PATH]; fgets(lasturl, MAX_PATH, f); SendMessage(url, WM_SETTEXT, 0, (LPARAM) lasturl); SendMessage(url, EM_SETSEL, 0, -1); fclose(f); } break; case WM_KEYDOWN: switch (LOWORD(wParam)) { case VK_RETURN: SendMessage(hwnd, WM_COMMAND, (WPARAM) ID_OK, 0); break; } case WM_COMMAND: { switch (LOWORD(wParam)) { case ID_CANCEL: DestroyWindow(hwnd); return 0; case ID_OK: { char file[MAX_PATH]; SendMessage(url, WM_GETTEXT, MAX_PATH, (LPARAM) file); mplSetFileName(NULL, file, STREAMTYPE_STREAM); if((f = fopen(history, "wt+"))) { fprintf(f, file); fclose(f); } if(!parse_filename(file, playtree, mconfig, addurl? 0 : 1)) gui->playlist->add_track(gui->playlist, file, NULL, NULL, 0); if(!addurl) gui->startplay(gui); else update_playlistwindow(); DestroyWindow(hwnd); } break; } } return 0; case WM_DESTROY: { addurl = 0; return 0; } } return DefWindowProc(hwnd, iMsg, wParam, lParam); }
/** * Runs a single test. * * @param[in] filename * @param[in] cfg * @return A pointer to the instance of htp_connp_t created during * the test, or NULL if the test failed for some reason. */ int test_run_ex(const char *testsdir, const char *testname, htp_cfg_t *cfg, htp_connp_t **connp, int clone_count) { char filename[1025]; test_t test; struct timeval tv_start, tv_end; int rc; *connp = NULL; strncpy(filename, testsdir, 1024); strncat(filename, "/", 1024 - strlen(filename)); strncat(filename, testname, 1024 - strlen(filename)); // printf("Filename: %s\n", filename); // Initinialize test rc = test_init(&test, filename, clone_count); if (rc < 0) { return rc; } gettimeofday(&tv_start, NULL); test_start(&test); // Create parser *connp = htp_connp_create(cfg); if (*connp == NULL) { fprintf(stderr, "Failed to create connection parser\n"); exit(1); } htp_connp_set_user_data(*connp, (void *) 0x02); // Does the filename contain connection metdata? if (strncmp(testname, "stream", 6) == 0) { // It does; use it char *remote_addr = NULL, *local_addr = NULL; int remote_port = -1, local_port = -1; parse_filename(testname, &remote_addr, &remote_port, &local_addr, &local_port); htp_connp_open(*connp, (const char *) remote_addr, remote_port, (const char *) local_addr, local_port, &tv_start); free(remote_addr); free(local_addr); } else { // No connection metadata; provide some fake information instead htp_connp_open(*connp, (const char *) "127.0.0.1", 10000, (const char *) "127.0.0.1", 80, &tv_start); } // Find all chunks and feed them to the parser int in_data_other = 0; char *in_data = NULL; size_t in_data_len = 0; size_t in_data_offset = 0; int out_data_other = 0; char *out_data = NULL; size_t out_data_len = 0; size_t out_data_offset = 0; for (;;) { if (test_next_chunk(&test) <= 0) { break; } if (test.chunk_direction == CLIENT) { if (in_data_other) { test_destroy(&test); fprintf(stderr, "Unable to buffer more than one inbound chunk.\n"); return -1; } rc = htp_connp_req_data(*connp, &tv_start, test.chunk, test.chunk_len); if (rc == HTP_STREAM_ERROR) { test_destroy(&test); return -101; } if (rc == HTP_STREAM_DATA_OTHER) { // Parser needs to see the outbound stream in order to continue // parsing the inbound stream. in_data_other = 1; in_data = test.chunk; in_data_len = test.chunk_len; in_data_offset = htp_connp_req_data_consumed(*connp); } } else { if (out_data_other) { rc = htp_connp_res_data(*connp, &tv_start, out_data + out_data_offset, out_data_len - out_data_offset); if (rc == HTP_STREAM_ERROR) { test_destroy(&test); return -104; } out_data_other = 0; } rc = htp_connp_res_data(*connp, &tv_start, test.chunk, test.chunk_len); if (rc == HTP_STREAM_ERROR) { test_destroy(&test); return -102; } if (rc == HTP_STREAM_DATA_OTHER) { // Parser needs to see the outbound stream in order to continue // parsing the inbound stream. out_data_other = 1; out_data = test.chunk; out_data_len = test.chunk_len; out_data_offset = htp_connp_res_data_consumed(*connp); // printf("# YYY out offset is %d\n", out_data_offset); } if (in_data_other) { rc = htp_connp_req_data(*connp, &tv_start, in_data + in_data_offset, in_data_len - in_data_offset); if (rc == HTP_STREAM_ERROR) { test_destroy(&test); return -103; } in_data_other = 0; } } } if (out_data_other) { rc = htp_connp_res_data(*connp, &tv_start, out_data + out_data_offset, out_data_len - out_data_offset); if (rc == HTP_STREAM_ERROR) { test_destroy(&test); return -104; } out_data_other = 0; } gettimeofday(&tv_end, NULL); // Close the connection htp_connp_close(*connp, &tv_end); // Clean up test_destroy(&test); return 1; }
// opens the file, registers an error code in command->error if necessary // If the open was successful, setup a channel for the given channel number // (note: explicitely not secondary device number, as IEEE and IEC in parallel // use overlapping numbers, so they may be shifted or similar to avoid clashes) // // The command buffer is used as transmit buffer, so it must not be overwritten // until the open has been sent. // // note that if it returns a value <0 on error, it has to have the error message // set appropriately. // int8_t file_open(uint8_t channel_no, bus_t *bus, errormsg_t *errormsg, void (*callback)(int8_t errnum, uint8_t *rxdata), uint8_t openflag) { assert_not_null(bus, "file_open: bus is null"); cmd_t *command = &(bus->command); rtconfig_t *rtconf = &(bus->rtconf); #ifdef DEBUG_FILE debug_printf("OPEN FILE: FOR CHAN: %d WITH NAME: '%s', OPENFLAG=%d\n", channel_no, (char*)&(command->command_buffer), openflag); #endif // note: in a preemtive env, the following would have to be protected // to be atomic as we modify static variables parse_filename(command, &nameinfo, (openflag & OPENFLAG_LOAD) ? PARSEHINT_LOAD : 0); #ifdef DEBUG_FILE debug_printf(" PARSE -> ACCESS=%c, TYPE=%c\n", nameinfo.access, nameinfo.type); #endif // drive handling needed for error message drive if (nameinfo.drive == NAMEINFO_LAST_DRIVE) { nameinfo.drive = rtconf->last_used_drive; } else if (nameinfo.drive == NAMEINFO_UNUSED_DRIVE) { // TODO: match CBM behavior nameinfo.drive = rtconf->last_used_drive; } int8_t errdrive = rtconf->errmsg_with_drive ? nameinfo.drive : -1; // post-parse if (nameinfo.cmd != CMD_NONE && nameinfo.cmd != CMD_DIR && nameinfo.cmd != CMD_OVERWRITE) { // command name during open // this is in fact ignored by CBM DOS as checked with VICE's true drive emulation debug_printf("NO CORRECT CMD: %s\n", command_to_name(nameinfo.cmd)); nameinfo.cmd = 0; } if (nameinfo.type != 0 && nameinfo.type != 'S' && nameinfo.type != 'P' && nameinfo.type != 'U' && nameinfo.type != 'L') { // not set, or set as not sequential and not program debug_puts("UNKOWN FILE TYPE: "); debug_putc(nameinfo.type); debug_putcrlf(); set_error_tsd(errormsg, CBM_ERROR_FILE_TYPE_MISMATCH, 0, 0, errdrive); return -1; } if (nameinfo.access != 0 && nameinfo.access != 'W' && nameinfo.access != 'R' && nameinfo.access != 'A' && nameinfo.access != 'X') { debug_puts("UNKNOWN FILE ACCESS TYPE "); debug_putc(nameinfo.access); debug_putcrlf(); // not set, or set as not read, write, or append, or r/w ('X') set_error_tsd(errormsg, CBM_ERROR_SYNTAX_UNKNOWN, 0, 0, errdrive); return -1; } if (nameinfo.cmd == CMD_DIR && (nameinfo.access != 0 && nameinfo.access != 'R')) { // trying to write to a directory debug_puts("WRITE TO DIRECTORY!"); debug_putcrlf(); set_error_tsd(errormsg, CBM_ERROR_FILE_EXISTS, 0, 0, errdrive); return -1; } uint8_t type = FS_OPEN_RD; // file access default if (nameinfo.access == 0) { if (openflag == OPENFLAG_LOAD) { nameinfo.access = 'R'; } else if (openflag == OPENFLAG_SAVE) { nameinfo.access = 'W'; } } // file type defaults if (nameinfo.type == 0) { // do we create a file (access=='W')? if (nameinfo.access == 'W') { // write (like save) if (openflag == OPENFLAG_SAVE) { nameinfo.type = 'P'; } else { nameinfo.type = 'S'; } } if (nameinfo.access == 'R') { if (openflag == OPENFLAG_LOAD) { // on load, 'P' is the default nameinfo.type = 'P'; } } } if (nameinfo.access == 'X') { // trying to open up a R/W channel debug_puts("OPENING UP A R/W CHANNEL!"); debug_putcrlf(); type = FS_OPEN_RW; } if (nameinfo.name[0] == '#') { // trying to open up a direct channel // Note: needs to be supported for D64 support with U1/U2/... // Note: '#' is still blocking on read! debug_puts("OPENING UP A DIRECT CHANNEL!"); debug_putcrlf(); type = FS_OPEN_DIRECT; } // if ",W" or secondary address is one, i.e. save if (nameinfo.access == 'W') { type = FS_OPEN_WR; } if (nameinfo.access == 'A') { type = FS_OPEN_AP; } if (nameinfo.cmd == CMD_DIR) { if (openflag & OPENFLAG_LOAD) { type = FS_OPEN_DR; } else { type = FS_OPEN_RD; } } else if (nameinfo.cmd == CMD_OVERWRITE) { type = FS_OPEN_OW; } #ifdef DEBUG_FILE debug_printf("NAME='%s' (%d)\n", nameinfo.name, nameinfo.namelen); debug_printf("ACCESS=%c\n", nameinfo.access); debug_printf("CMD=%d\n", nameinfo.cmd); debug_flush(); #endif return file_submit_call(channel_no, type, command->command_buffer, errormsg, rtconf, callback, 0); }
size_t tool_header_cb(void *ptr, size_t size, size_t nmemb, void *userdata) { struct HdrCbData *hdrcbdata = userdata; struct OutStruct *outs = hdrcbdata->outs; struct OutStruct *heads = hdrcbdata->heads; const char *str = ptr; const size_t cb = size * nmemb; const char *end = (char*)ptr + cb; /* * Once that libcurl has called back tool_header_cb() the returned value * is checked against the amount that was intended to be written, if * it does not match then it fails with CURLE_WRITE_ERROR. So at this * point returning a value different from sz*nmemb indicates failure. */ size_t failure = (size * nmemb) ? 0 : 1; if(!heads->config) return failure; #ifdef DEBUGBUILD if(size * nmemb > (size_t)CURL_MAX_HTTP_HEADER) { warnf(heads->config->global, "Header data exceeds single call write " "limit!\n"); return failure; } #endif /* * Write header data when curl option --dump-header (-D) is given. */ if(heads->config->headerfile && heads->stream) { size_t rc = fwrite(ptr, size, nmemb, heads->stream); if(rc != cb) return rc; /* flush the stream to send off what we got earlier */ (void)fflush(heads->stream); } /* * This callback sets the filename where output shall be written when * curl options --remote-name (-O) and --remote-header-name (-J) have * been simultaneously given and additionally server returns an HTTP * Content-Disposition header specifying a filename property. */ if(hdrcbdata->honor_cd_filename && (cb > 20) && checkprefix("Content-disposition:", str)) { const char *p = str + 20; /* look for the 'filename=' parameter (encoded filenames (*=) are not supported) */ for(;;) { char *filename; size_t len; while(*p && (p < end) && !ISALPHA(*p)) p++; if(p > end - 9) break; if(memcmp(p, "filename=", 9)) { /* no match, find next parameter */ while((p < end) && (*p != ';')) p++; continue; } p += 9; /* this expression below typecasts 'cb' only to avoid warning: signed and unsigned type in conditional expression */ len = (ssize_t)cb - (p - str); filename = parse_filename(p, len); if(filename) { outs->filename = filename; outs->alloc_filename = TRUE; outs->is_cd_filename = TRUE; outs->s_isreg = TRUE; outs->fopened = FALSE; outs->stream = NULL; hdrcbdata->honor_cd_filename = FALSE; break; } else return failure; } } return cb; }
void get_files( CAMHandle hCam, CAMDeviceInfoPtr pDevInfo, OPTS *pOpts) { int ret; int fName; char *pName; uint32_t *pHandle; uint32_t *pEnd; CAMObjectHandlePtr pHandles = 0; CAMObjectInfoPtr pObjInfo = 0; FNSTRUCT fns; char path[260]; if (GetObjectHandles( hCam, 0xffffffff, 0, 0, &pHandles)) { camcli_error( "Could not get object handles"); return; } fName = parse_filename( pOpts->value, &fns); if (fName) pName = path; else pName = 0; if (!validate_range( pHandles, pOpts, &pHandle, &pEnd)) { if (pHandles) free( pHandles); return; } if (pOpts->flags & OPT_THUMBNAIL) { printf ( "\n Save thumbnails %s\n", pDevInfo->Model); printf ( " =============== %s\n", underline( pDevInfo->Model)); } else { printf ( "\n Save files %s\n", pDevInfo->Model); printf ( " ========== %s\n", underline( pDevInfo->Model)); } for (; pHandle <= pEnd; pHandle++) { ret = GetObjectInfo( hCam, *pHandle, &pObjInfo); if (ret) { camcli_error( "Could not get info for handle %d", *pHandle); if (ret == CAMERR_USBFAILURE) ClearStall( hCam); continue; } if (pObjInfo->ObjectFormat == PTP_OFC_Association) printf( " Handle %d is not a file - skipping...\n", *pHandle); else { if (fName) make_filename( pName, pObjInfo->Filename, &fns); ret = os2_get_file( hCam, pObjInfo, *pHandle, pName, (pOpts->flags & OPT_REPLACE), (pOpts->flags & OPT_THUMBNAIL)); if (ret == CAMERR_USBFAILURE) ClearStall( hCam); } free( pObjInfo); pObjInfo = 0; } if (pObjInfo) free( pObjInfo); if (pHandles) free( pHandles); return; }
int chain_2 (int argc, char *argv[]) { FILE *in; char line[256], filename[80] = "", *destination[NUMDEST], outfile[80] = ""; char *subject[NUMSUB], *t; int chain[HOPMAX]; byte numdest = 0, numsub = 0; int i, num_remailers, outfileflag = 0; REMAILER remailer_list[256]; int filter = 0, rfcmsg = 0, dummy = 0; num_remailers = read_remailer_list (remailer_list); chain[0] = 0; /* what is in those arguments */ /* Here is the expected format */ /* mixmaster [-c][-f][filename][-[o,O] outfile][-to who@where][-s "subject"][-l 1 2 3 4] */ /* if no outfile given, then pipe to sendmail. outfile = stdout send to stdout */ for (i = 1; i < argc; i++) { if (streq (argv[i], "-c")) { /* nop */ } else if (strleft (argv[i], "-h") || streq (argv[i], "--help")) { /* Print help and exit */ printf ("Mixmaster %s (C) Copyright Lance M. Cottrell 1995, 1996\n", VERSION); printf ("Released under the GNU public license. No warranty!\n\n"); printf ("Client Mode command line arguments:\n"); printf ("mixmaster [-c] [infile] [-f] [-m] [-s subject] [-v 'Header: text' [-v ...]]\n[-n numcopies] [-[o,O] outfile] [-to who@where] [-l 1 2 3 ...]\n"); exit (-1); } else if (streq (argv[i], "-f")) { /* set filter mode */ filter = 1; } else if (streq (argv[i], "-m")) { filter = 1; rfcmsg = 1; } else if (streq (argv[i], "-d")) { filter = 1; destination[0] = (char *) calloc (1, DESTSIZE); strcpy (destination[0], "null:"); numdest = 1; REQUIRE[0] = '\0'; REJECT[0] = '\0'; dummy = 5 + random_number (11); } else if (streq (argv[i], "-s")) { if (i < argc - 1) i++; subject[numsub] = (char *) calloc (1, SUBSIZE); strcpy (subject[numsub], "Subject: "); strncat (subject[numsub], argv[i], SUBSIZE - sizeof ("Subject: ")); numsub++; } else if (streq (argv[i], "-v")) { if (i < argc - 1) i++; subject[numsub] = (char *) calloc (1, SUBSIZE); subject[numsub][0] = 0; strncat (subject[numsub], argv[i], SUBSIZE - 1); numsub++; } else if (streq (argv[i], "-o") || streq (argv[i], "-O")) { if (streq (argv[i], "-O")) outfileflag = 1; /* add To: line */ if (i < argc - 1) i++; if (streq (argv[i], "stdout")) strcpy (outfile, "-"); else parse_filename (outfile, argv[i]); } else if (streq (argv[i], "-n")) { if (i < argc - 1) i++; sscanf (argv[i], "%d", &NUMCOPIES); } else if (streq (argv[i], "-to") && numdest < NUMDEST) { if (i < argc - 1) i++; destination[numdest] = (char *) calloc (1, DESTSIZE); strncpy (destination[numdest], argv[i], DESTSIZE - 1); destination[numdest][DESTSIZE - 1] = '\0'; chop (destination[numdest]); numdest++; } else if (streq (argv[i], "-l")) { for (i++; i < argc && chain[0] < HOPMAX; i++) if ((chain[++chain[0]] = select_remailer (remailer_list, num_remailers, argv[i])) < 0) exit (-1); /* Invalid remailer */ } else { if (strlen (filename) != 0) { fprintf (errlog, "problem with the command line\n"); return (-1); } strncpy (filename, argv[i], sizeof (filename)); } } if (numdest == 0 && !rfcmsg) { if (!filter) fprintf (errlog, "Enter final destinations (one per line return when done).\n"); do { if (!filter) fprintf (errlog, "Enter destination :"); getline (line, sizeof (line), stdin); if (strlen (line) >= 2 && numdest < NUMDEST) { destination[numdest] = (char *) calloc (1, DESTSIZE); strncpy (destination[numdest], line, DESTSIZE - 1); destination[numdest][DESTSIZE - 1] = '\0'; numdest++; } } while (strlen (line) > 0 || numdest == 0); } if (numdest == 0 && filter && !rfcmsg) exit (-1); /* no destination and in filter mode */ if (numsub == 0 && !dummy) { if (!filter) { fprintf (errlog, "Enter message headers (one per line, return when done).\n"); fprintf (errlog, "You must include the header name, e.g. 'Subject: foo'\n"); } do { if (!filter) fprintf (errlog, "Enter header :"); getline (line, sizeof (line), stdin); if (rfcmsg && (strileft (line, "To:") || strileft (line, "Newsgroups:")) && numdest < NUMDEST) { destination[numdest] = (char *) calloc (1, DESTSIZE); if (strileft (line, "To:")) { t = line + sizeof ("To:") - 1; while (*t == ' ' || *t == '\t') t++; strncpy (destination[numdest], t, DESTSIZE - 1); } else { t = line + sizeof ("Newsgroups:") - 1; while (*t == ' ' || *t == '\t') t++; strcpy (destination[numdest], "post: "); strncat (destination[numdest], t, DESTSIZE - sizeof ("post: ")); } destination[numdest][DESTSIZE - 1] = '\0'; numdest++; } else if (strlen (line) > 0 && numsub < NUMSUB) { subject[numsub] = (char *) calloc (1, SUBSIZE); strncpy (subject[numsub], line, SUBSIZE - 1); subject[numsub][SUBSIZE - 1] = '\0'; numsub++; } } while (strlen (line) > 0); } if (!strchr (REQUIRE, 'N')) for (i = 0; i < numdest; i++) if (strileft (destination[i], "post:")) { strcat (REQUIRE, "N"); break; } if (chain[0] == 0 && strlen (CHAIN)) if (scan_remailer_list (CHAIN, chain, remailer_list, num_remailers) < 0) return (-1); if (chain[0] == 0 && dummy) { while (chain[0] < dummy) chain[++chain[0]] = 0; } if (chain[0] == 0 && !filter) { get_chain (remailer_list, num_remailers, chain); } if (chain[0] == 0) { return (-1); } #if 1 if ((chain[chain[0]] > 0) && check_abilities (remailer_list[chain[chain[0]]].abilities, REQUIRE, REJECT) == 0) { fprintf (errlog, "Warning: Remailer %s has insufficient capabilities!\n", remailer_list[chain[chain[0]]].shortname); } #else while ((chain[chain[0]] > 0) && check_abilities (remailer_list[chain[chain[0]]].abilities, REQUIRE, REJECT) == 0) { fprintf (errlog, "Remailer %s has insufficient capabilities!\n", remailer_list[chain[chain[0]]].shortname); if (!filter) { chain[0]--; get_chain (remailer_list, num_remailers, chain); } else exit (-1); } #endif /* if file = stdin then I will take stdin */ if (strlen (filename) == 0 && !filter) { fprintf (errlog, "Please enter the name of the file to chain: "); getline (filename, sizeof (filename), stdin); } if (streq (filename, "stdin")) strcpy (filename, "-"); parse_filename (line, filename); if (dummy) in = NULL; else if (streq (filename, "-") || strlen (filename) == 0) { if (!filter) fprintf (errlog, "Please enter the message.\n"); in = stdin; } else in = open_user_file (line, "r"); /* ok, that should be everything we need to know */ #ifdef DEBUG printf ("filtermode %d\n", filter); /*debug */ printf ("source file %s\n", filename); /*debug */ printf ("#destinations %d\n", numdest); /*debug */ for (i = 0; i < numdest; i++) printf ("destination %d %s\n", i, destination[i]); /*debug */ for (i = 1; i <= chain[0]; i++) printf ("remailer %d\n", chain[i]); /*debug */ for (i = 0; i < numsub; i++) printf ("header %d %s\n", i, subject[i]); /*debug */ #endif return (build_message (in, numdest, destination, chain, numsub, subject, outfile, outfileflag, remailer_list, num_remailers, 1)); }
size_t tool_header_cb(char *ptr, size_t size, size_t nmemb, void *userdata) { struct HdrCbData *hdrcbdata = userdata; struct OutStruct *outs = hdrcbdata->outs; struct OutStruct *heads = hdrcbdata->heads; const char *str = ptr; const size_t cb = size * nmemb; const char *end = (char *)ptr + cb; long protocol = 0; /* * Once that libcurl has called back tool_header_cb() the returned value * is checked against the amount that was intended to be written, if * it does not match then it fails with CURLE_WRITE_ERROR. So at this * point returning a value different from sz*nmemb indicates failure. */ size_t failure = (size && nmemb) ? 0 : 1; if(!heads->config) return failure; #ifdef DEBUGBUILD if(size * nmemb > (size_t)CURL_MAX_HTTP_HEADER) { warnf(heads->config->global, "Header data exceeds single call write " "limit!\n"); return failure; } #endif /* * Write header data when curl option --dump-header (-D) is given. */ if(heads->config->headerfile && heads->stream) { size_t rc = fwrite(ptr, size, nmemb, heads->stream); if(rc != cb) return rc; /* flush the stream to send off what we got earlier */ (void)fflush(heads->stream); } /* * This callback sets the filename where output shall be written when * curl options --remote-name (-O) and --remote-header-name (-J) have * been simultaneously given and additionally server returns an HTTP * Content-Disposition header specifying a filename property. */ curl_easy_getinfo(outs->config->easy, CURLINFO_PROTOCOL, &protocol); if(hdrcbdata->honor_cd_filename && (cb > 20) && checkprefix("Content-disposition:", str) && (protocol & (CURLPROTO_HTTPS|CURLPROTO_HTTP))) { const char *p = str + 20; if(!outs->stream && !tool_create_output_file(outs, FALSE)) return failure; /* look for the 'filename=' parameter (encoded filenames (*=) are not supported) */ for(;;) { char *filename; size_t len; while(*p && (p < end) && !ISALPHA(*p)) p++; if(p > end - 9) break; if(memcmp(p, "filename=", 9)) { /* no match, find next parameter */ while((p < end) && (*p != ';')) p++; continue; } p += 9; /* this expression below typecasts 'cb' only to avoid warning: signed and unsigned type in conditional expression */ len = (ssize_t)cb - (p - str); filename = parse_filename(p, len); if(filename) { if(outs->stream) { /* already opened and possibly written to */ if(outs->fopened) fclose(outs->stream); outs->stream = NULL; /* rename the initial file name to the new file name */ rename(outs->filename, filename); if(outs->alloc_filename) free(outs->filename); } outs->is_cd_filename = TRUE; outs->s_isreg = TRUE; outs->fopened = FALSE; outs->filename = filename; outs->alloc_filename = TRUE; hdrcbdata->honor_cd_filename = FALSE; /* done now! */ if(!tool_create_output_file(outs, TRUE)) return failure; } break; } } if(hdrcbdata->config->show_headers && (protocol & (CURLPROTO_HTTP|CURLPROTO_HTTPS|CURLPROTO_RTSP))) { /* bold headers only happen for HTTP(S) and RTSP */ char *value = NULL; if(!outs->stream && !tool_create_output_file(outs, FALSE)) return failure; if(hdrcbdata->global->isatty && hdrcbdata->global->styled_output) value = memchr(ptr, ':', cb); if(value) { size_t namelen = value - ptr; fprintf(outs->stream, BOLD "%.*s" BOLDOFF ":", namelen, ptr); fwrite(&value[1], cb - namelen - 1, 1, outs->stream); } else /* not "handled", just show it */ fwrite(ptr, cb, 1, outs->stream); } return cb; }
int main(int argc, char *argv[]) { #else int OCG_main(char is_local_server[FILENAME_LENGTH_MAX]) { #endif int state = STATE_START_OCG; char web_XML_folder[DIR_LENGTH_MAX] = ""; char output_dir[DIR_LENGTH_MAX] = ""; // the output folder during the OCG procedure. Change step by step char *OPENAIR_TARGETS=getenv("OPENAIR_TARGETS"); if (OPENAIR_TARGETS == NULL) { LOG_E(OCG, "please set the PATH for OPENAIR_TARGETS"); exit(EXIT_FAILURE); } if (!strcmp(is_local_server, "0")) { // Eurecom web server strcpy(web_XML_folder, WEB_XML_FOLDER); strcat(output_dir, OUTPUT_DIR); } else { // local user sprintf(web_XML_folder,"%s/SIMU/EXAMPLES/OSD/WEBXML/",getenv("OPENAIR_TARGETS")); sprintf(output_dir,"%s/SIMU/EXAMPLES/OSD/RESULTS/",getenv("OPENAIR_TARGETS")); /* strcpy(web_XML_folder, OPENAIR_TARGETS); strcpy(output_dir, OPENAIR_TARGETS); char *slash; slash = web_XML_folder + strlen(web_XML_folder) - 1; if (strcmp(slash, "/")) { // check if the path OPENAIR_TARGETS is ended with a '/' strcat(web_XML_folder, "/"); strcat(output_dir, "/"); } strcat(web_XML_folder, "SIMU/EXAMPLES/OSD/WEBXML/"); strcat(output_dir, "SIMU/EXAMPLES/OSD/RESULTS/"); */ } LOG_I(OCG, "Folder for detecting the XML configuration file is %s\n", web_XML_folder); LOG_I(OCG, "Folder for generating the results is %s\n", output_dir); LOG_I(OCG, "OSD XML config file is %s\n", is_local_server); while(state != STATE_END) { switch(state) { case STATE_START_OCG : LOG_I(OCG, "OCG starts ...\n\n"); get_opt_OK = MODULE_NOT_PROCESSED; // -9999 is the initial value, representing the module not processed detect_file_OK = MODULE_NOT_PROCESSED; create_dir_OK = MODULE_NOT_PROCESSED; // to write the pid into a file 'OCG.pid' so that the web portal part could check if OCG is running /* pid_t pid; pid = getpid(); FILE *OCG_pid; OCG_pid = fopen("OCG.pid", "w"); fprintf(OCG_pid, "%d\n", pid); fclose(OCG_pid); */ #ifdef TEST_OCG state = STATE_GET_OPT; case STATE_GET_OPT : get_opt_OK = get_opt(argc, argv); if (get_opt_OK == MODULE_OK) { strcpy(src_file, LOCAL_XML_FOLDER); copy_or_move = 1; state = STATE_INI_EMU; } else if (get_opt_OK == GET_HELP) state = STATE_END; else state = STATE_DETECT_FILE; break; #else state = STATE_DETECT_FILE; //get_opt_OK == MODULE_OK; #endif case STATE_DETECT_FILE : strcpy(src_file, web_XML_folder); detect_file_OK = detect_file(src_file, is_local_server); if (detect_file_OK == MODULE_OK) { if ((!strcmp(is_local_server, "0")) || (!strcmp(is_local_server, "-1"))) copy_or_move = 2; state = STATE_INI_EMU; } else if (detect_file_OK == MODULE_ERROR) state = STATE_GENERATE_REPORT; else if (detect_file_OK == NO_FILE) { state = STATE_DETECT_FILE; sleep(1); } break; case STATE_INI_EMU : // before initiating an emu, an XML file should be found above parse_filename_OK = MODULE_NOT_PROCESSED; create_dir_OK = MODULE_NOT_PROCESSED; parse_XML_OK = MODULE_NOT_PROCESSED; save_XML_OK = MODULE_NOT_PROCESSED; // call_emu_OK = MODULE_NOT_PROCESSED; //config_mobi_OK = MODULE_NOT_PROCESSED; generate_report_OK = MODULE_NOT_PROCESSED; LOG_I(OCG, "An emulation for file %s is initiated\n", filename); state = STATE_PARSE_FILENAME; break; case STATE_PARSE_FILENAME : strcat(src_file, filename); if ((parse_filename_OK = parse_filename(filename)) == MODULE_OK) state = STATE_CREATE_DIR; else { if (copy_or_move == 2) { remove(src_file); state = STATE_DETECT_FILE; } else state = STATE_GENERATE_REPORT; } break; case STATE_CREATE_DIR : if ((create_dir_OK = create_dir(output_dir, user_name, file_date)) == MODULE_OK) { state = STATE_PARSE_XML; strcat(output_dir, user_name); strcat(output_dir, "/"); strcat(output_dir, file_date); strcat(output_dir, "/"); strcpy(dst_dir, output_dir); oai_emulation.info.output_path = dst_dir; // information for other modules within OAI } else state = STATE_GENERATE_REPORT; break; case STATE_PARSE_XML : if ((parse_XML_OK = parse_XML(src_file)) == MODULE_OK) state = STATE_SAVE_XML; else { if (copy_or_move == 2) remove(src_file); state = STATE_GENERATE_REPORT; } break; case STATE_SAVE_XML : if ((save_XML_OK = save_XML(copy_or_move, src_file, output_dir, filename)) == MODULE_OK) state = STATE_CALL_EMU; else state = STATE_GENERATE_REPORT; break; case STATE_CALL_EMU : // change this state to set_params if ((detect_file_OK == MODULE_OK) && (parse_filename_OK == MODULE_OK) && (create_dir_OK == MODULE_OK) && (parse_XML_OK == MODULE_OK) && (save_XML_OK == MODULE_OK)) { // if the above tasks are all successful, we could tell the oaisim_config.c that everything is ready before running the emulation oai_emulation.info.ocg_ok = 1; } #ifdef TEST_OCG call_emu_OK = call_emu(output_dir); // config_mobi_OK = config_mobi("RWMEmulator.xml", filename); // generate the XML for Mobigen #endif state = STATE_GENERATE_REPORT; break; case STATE_GENERATE_REPORT : if (create_dir_OK != MODULE_OK) { // a temp folder is required when the output folder could not be correctly generated strncpy(output_dir, OPENAIR_TARGETS, sizeof(output_dir)); output_dir[sizeof(output_dir) - 1] = 0; // terminate string strncat(output_dir, "SIMU/EXAMPLES/OSD/", sizeof(output_dir) - strlen(output_dir) - 1); strncat(output_dir, TEMP_OUTPUT_DIR, sizeof(output_dir) - strlen(output_dir) - 1); struct stat st; if(stat(output_dir, &st) != 0) { // if temp output directory does not exist, we create it here mkdir(output_dir, S_IRWXU | S_IRWXG | S_IRWXO); LOG_I(OCG, "temp output directory %s is created", output_dir); } } else { //strcat(output_dir, "SCENARIO/STATE/"); // if needeed the outpur directory can be further set LOG_I(OCG, "Output directory is %s \n", output_dir); } generate_report(output_dir, "OCG_report.xml"); if (copy_or_move == 1) state = STATE_END; else state = STATE_END; //else state = STATE_DETECT_FILE; break; } } // end while // Cleanup function for the XML library. xmlCleanupParser(); // this is to debug memory for regression tests xmlMemoryDump(); LOG_I(OCG, "... OCG ends\n\n"); #ifdef TEST_OCG return 0; #else return 1; #endif }