/* <string> .libfile <string> false */ int /* exported for zsysvm.c */ zlibfile(i_ctx_t *i_ctx_p) { os_ptr op = osp; int code; byte cname[DEFAULT_BUFFER_SIZE]; uint clen; gs_parsed_file_name_t pname; stream *s; gx_io_device *iodev_dflt; check_ostack(2); code = parse_file_name(op, &pname, i_ctx_p->LockFilePermissions, imemory); if (code < 0) return code; iodev_dflt = iodev_default(imemory); if (pname.iodev == NULL) pname.iodev = iodev_dflt; if (pname.iodev != iodev_dflt) { /* Non-OS devices don't have search paths (yet). */ code = zopen_file(i_ctx_p, &pname, "r", &s, imemory); if (code >= 0) { code = ssetfilename(s, op->value.const_bytes, r_size(op)); if (code < 0) { sclose(s); return_error(e_VMerror); } } if (code < 0) { push(1); make_false(op); return 0; } make_stream_file(op, s, "r"); } else { ref fref; code = lib_file_open(i_ctx_p->lib_path, imemory, i_ctx_p, pname.fname, pname.len, (char *)cname, sizeof(cname), &clen, &fref); if (code >= 0) { s = fptr(&fref); code = ssetfilename(s, cname, clen); if (code < 0) { sclose(s); return_error(e_VMerror); } } if (code < 0) { if (code == e_VMerror || code == e_invalidfileaccess) return code; push(1); make_false(op); return 0; } ref_assign(op, &fref); } push(1); make_true(op); return 0; }
/* Parse a real (non-device) file name and convert to a C string. */ int parse_real_file_name(const ref *op, parsed_file_name *pfn, client_name_t cname) { int code = parse_file_name(op, pfn); if ( code < 0 ) return code; if ( pfn->len == 0 ) return_error(e_invalidfileaccess); /* device only */ return terminate_file_name(pfn, cname); }
static int zfilenameforall(i_ctx_t *i_ctx_p) { os_ptr op = osp; file_enum *pfen; gx_io_device *iodev = NULL; gs_parsed_file_name_t pname; int code = 0; check_write_type(*op, t_string); check_proc(op[-1]); check_read_type(op[-2], t_string); /* Push a mark, the iodev, devicenamelen, the scratch string, the enumerator, */ /* and the procedure, and invoke the continuation. */ check_estack(7); /* Get the iodevice */ code = parse_file_name(op - 2, &pname, i_ctx_p->LockFilePermissions); if (code < 0) return code; iodev = (pname.iodev == NULL) ? iodev_default : pname.iodev; /* Check for several conditions that just cause us to return success */ if (pname.len == 0 || iodev->procs.enumerate_files == iodev_no_enumerate_files) { pop(3); return 0; /* no pattern, or device not found -- just return */ } pfen = iodev->procs.enumerate_files(iodev, (const char *)pname.fname, pname.len, imemory); if (pfen == 0) return_error(e_VMerror); push_mark_estack(es_for, file_cleanup); ++esp; make_istruct(esp, 0, iodev); ++esp; make_int(esp, r_size(op-2) - pname.len); *++esp = *op; ++esp; make_istruct(esp, 0, pfen); *++esp = op[-1]; pop(3); code = file_continue(i_ctx_p); return (code == o_pop_estack ? o_push_estack : code); }
Bool add_KDE_colorscheme( const char *new_cs_file ) { Bool success = False; #define KDE_CSRC_PATH "$KDEHOME/share/apps/kdisplay/color-schemes/" if( new_cs_file ) { int i = 1; char *dst_path ; char *dst_full_fname ; char *fname = NULL ; parse_file_name(new_cs_file, NULL, &fname ); dst_path = copy_replace_envvar( KDE_CSRC_PATH ); while( dst_path[i] != '\0' ) { if( dst_path[i] == '/' ) { char t = dst_path[i]; dst_path[i] = '\0' ; if (CheckDir (dst_path) != 0) mkdir (dst_path, 0755); dst_path[i] = t ; } ++i; } dst_full_fname = safemalloc( i+strlen(fname)+1 ); sprintf( dst_full_fname, "%s%s", dst_path, fname ); success = (CopyFile( new_cs_file, dst_full_fname )==0); free( dst_full_fname ); free( dst_path ); free( fname ); } return success; }
/* <string> status false */ static int zstatus(i_ctx_t *i_ctx_p) { os_ptr op = osp; switch (r_type(op)) { case t_file: { stream *s; make_bool(op, (file_is_valid(s, op) ? 1 : 0)); } return 0; case t_string: { gs_parsed_file_name_t pname; struct stat fstat; int code = parse_file_name(op, &pname, i_ctx_p->LockFilePermissions); if (code < 0) return code; code = gs_terminate_file_name(&pname, imemory, "status"); if (code < 0) return code; code = (*pname.iodev->procs.file_status)(pname.iodev, pname.fname, &fstat); switch (code) { case 0: check_ostack(4); /* * Check to make sure that the file size fits into * a PostScript integer. (On some systems, long is * 32 bits, but file sizes are 64 bits.) */ push(4); make_int(op - 4, stat_blocks(&fstat)); make_int(op - 3, fstat.st_size); /* * We can't check the value simply by using ==, * because signed/unsigned == does the wrong thing. * Instead, since integer assignment only keeps the * bottom bits, we convert the values to double * and then test for equality. This handles all * cases of signed/unsigned or width mismatch. */ if ((double)op[-4].value.intval != (double)stat_blocks(&fstat) || (double)op[-3].value.intval != (double)fstat.st_size ) return_error(e_limitcheck); make_int(op - 2, fstat.st_mtime); make_int(op - 1, fstat.st_ctime); make_bool(op, 1); break; case e_undefinedfilename: make_bool(op, 0); code = 0; } gs_free_file_name(&pname, "status"); return code; } default: return_op_typecheck(op); } }
/* <name_string> <access_string> file <file> */ int /* exported for zsysvm.c */ zfile(i_ctx_t *i_ctx_p) { os_ptr op = osp; char file_access[4]; gs_parsed_file_name_t pname; int code = parse_file_access_string(op, file_access); stream *s; if (code < 0) return code; code = parse_file_name(op - 1, &pname, i_ctx_p->LockFilePermissions); if (code < 0) return code; /* * HACK: temporarily patch the current context pointer into the * state pointer for stdio-related devices. See ziodev.c for * more information. */ if (pname.iodev && pname.iodev->dtype == iodev_dtype_stdio) { bool statement = (strcmp(pname.iodev->dname, "%statementedit%") == 0); bool lineedit = (strcmp(pname.iodev->dname, "%lineedit%") == 0); if (pname.fname) return_error(e_invalidfileaccess); if (statement || lineedit) { /* These need special code to support callouts */ gx_io_device *indev = gs_findiodevice((const byte *)"%stdin", 6); stream *ins; if (strcmp(file_access, "r")) return_error(e_invalidfileaccess); indev->state = i_ctx_p; code = (indev->procs.open_device)(indev, file_access, &ins, imemory); indev->state = 0; if (code < 0) return code; check_ostack(2); push(2); make_stream_file(op - 3, ins, file_access); make_bool(op-2, statement); make_int(op-1, 0); make_string(op, icurrent_space, 0, NULL); return zfilelineedit(i_ctx_p); } pname.iodev->state = i_ctx_p; code = (*pname.iodev->procs.open_device)(pname.iodev, file_access, &s, imemory); pname.iodev->state = NULL; } else { if (pname.iodev == NULL) pname.iodev = iodev_default; code = zopen_file(i_ctx_p, &pname, file_access, &s, imemory); } if (code < 0) return code; code = ssetfilename(s, op[-1].value.const_bytes, r_size(op - 1)); if (code < 0) { sclose(s); return_error(e_VMerror); } make_stream_file(op - 1, s, file_access); pop(1); return code; }
int main (int argc, char **argv) { program_name = argv[0]; /* Set locale according to user's wishes. */ setlocale (LC_ALL, ""); /* Tell program which translations to use and where to find. */ bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); for (;;) { int optc = getopt_long (argc, argv, "i:x:l:m:d:p:", long_options, (int *) 0); if (optc < 0) break; switch (optc) { case 0: break; case 'i': include_languages (optarg); break; case 'x': exclude_languages (optarg); break; case 'l': language_save_arg (optarg); break; case 'm': lang_map_file_name = optarg; break; case 'd': set_default_language (optarg); break; case 'p': if (cw_dlink == 0) cw_dlink = init_walker (&idh); prune_file_names (optarg, cw_dlink); break; default: usage (); } } if (show_version) { printf ("%s - %s\n", program_name, PACKAGE_VERSION); exit (0); } if (show_help) help_me (); argc -= optind; argv += optind; if (argc == 0) { static char dot[] = "."; static char *dotp = dot; argc = 1; argv = &dotp; } language_getopt (); if (cw_dlink == 0) cw_dlink = init_walker (&idh); parse_language_map (lang_map_file_name); while (argc--) { struct file_link *flink = parse_file_name (*argv++, cw_dlink); if (flink) walk_flink (flink, 0); } mark_member_file_links (&idh); obstack_init (&tokens_obstack); scan_files (&idh); return 0; }
uint8 FSDrive::open_file(int channel, const uint8 *name, int name_len) { char plain_name[NAMEBUF_LENGTH]; int plain_name_len; int mode = FMODE_READ; int type = FTYPE_PRG; int rec_len = 0; parse_file_name(name, name_len, (uint8 *)plain_name, plain_name_len, mode, type, rec_len, true); // Channel 0 is READ, channel 1 is WRITE if (channel == 0 || channel == 1) { mode = channel ? FMODE_WRITE : FMODE_READ; if (type == FTYPE_DEL) type = FTYPE_PRG; } bool writing = (mode == FMODE_WRITE || mode == FMODE_APPEND); // Expand wildcards (only allowed on reading) if (strchr(plain_name, '*') || strchr(plain_name, '?')) { if (writing) { set_error(ERR_SYNTAX33); return ST_OK; } else find_first_file(plain_name); } // Relative files are not supported if (type == FTYPE_REL) { set_error(ERR_UNIMPLEMENTED); return ST_OK; } // Select fopen() mode according to file mode const char *mode_str = "rb"; switch (mode) { case FMODE_WRITE: mode_str = "wb"; break; case FMODE_APPEND: mode_str = "ab"; break; } // Open file #ifndef __riscos__ if (chdir(dir_path)) set_error(ERR_NOTREADY); else if ((file[channel] = fopen(plain_name, mode_str)) != NULL) { if (mode == FMODE_READ || mode == FMODE_M) // Read and buffer first byte read_char[channel] = fgetc(file[channel]); } else set_error(ERR_FILENOTFOUND); #ifdef SPMP libgame_chdir_game(); #else chdir(AppDirPath); #endif #else { char fullname[NAMEBUF_LENGTH]; // On RISC OS make a full filename sprintf(fullname,"%s.%s",dir_path,plain_name); if ((file[channel] = fopen(fullname, mode)) != NULL) { if (mode == FMODE_READ || mode == FMODE_M) { read_char[channel] = fgetc(file[channel]); } } else { set_error(ERR_FILENOTFOUND); } } #endif return ST_OK; }
int spawn_child( const char *cmd, int singleton_id, int screen, const char *orig_display, Window w, int context, Bool do_fork, Bool pass_args, ... ) { int pid = 0; if( cmd == NULL ) return 0; if( as_init_singletons ) { register int i ; for( i = 0; i < MAX_SINGLETONS_NUM ; i++ ) as_singletons[i] = 0 ; signal (SIGCHLD, as_sigchild_handler); as_init_singletons = False ; } if( singleton_id >= 0 ) { if( singleton_id >= MAX_SINGLETONS_NUM ) singleton_id = MAX_SINGLETONS_NUM-1; if( as_singletons[singleton_id] > 0 ) check_singleton_child( singleton_id, True ); } if( do_fork ) pid = fork(); if( pid != 0 ) { /* there is a possibility of the race condition here * but it really is not worse the trouble to try and avoid it. */ if( singleton_id >= 0 ) as_singletons[singleton_id] = pid ; return pid; }else {/* we get here only in child process. We now need to spawn new proggy here: */ int len; char *display = mystrdup(XDisplayString (dpy)); char **envp ; register char *ptr ; char *cmdl; char *arg, *screen_str = NULL, *w_str = NULL, *context_str = NULL ; int env_s = 0; char **envvars = AS_environ ; int font_path_slot = -1, image_path_slot = -1 ; va_list ap; LOCAL_DEBUG_OUT( "dpy = %p, DisplayString = \"%s\"", dpy, display ); LOCAL_DEBUG_OUT( "pid(%d), entered child process to spawn ...", pid ); #if HAVE_DECL_ENVIRON if( envvars == NULL ) { envvars = environ ; } #else /* how the hell could we get environment otherwise ? */ #endif if( envvars ) { int font_path_len = strlen(ASFONT_PATH_ENVVAR); int image_path_len = strlen(ASIMAGE_PATH_ENVVAR); for( env_s = 0 ; envvars[env_s] != NULL ; ++env_s ) { if( font_path_slot < 0 && strlen(envvars[env_s]) > font_path_len ) if(strncmp(envvars[env_s], ASFONT_PATH_ENVVAR, font_path_len)==0) font_path_slot = env_s ; if( image_path_slot < 0 && strlen(envvars[env_s]) > image_path_len) if(strncmp(envvars[env_s], ASIMAGE_PATH_ENVVAR, image_path_len)==0) image_path_slot = env_s ; } } if( font_path_slot < 0 ) ++env_s ; if( image_path_slot < 0 ) ++env_s ; envp = safecalloc( env_s+2, sizeof(char*)); /* environment variabless to pass to child process */ if( envvars ) for( env_s = 0 ; envvars[env_s] != NULL ; ++env_s ) envp[env_s] = envvars[env_s] ; envp[env_s] = safemalloc(8+strlen(orig_display?orig_display:display)+1); sprintf( envp[env_s], "DISPLAY=%s", orig_display?orig_display:display ); ++env_s ; if( Environment ) { if( Environment->pixmap_path != NULL ) { int slot_no = image_path_slot ; if( slot_no < 0 ) slot_no = env_s++ ; envp[slot_no] = safemalloc(strlen( ASIMAGE_PATH_ENVVAR ) + 1 + strlen(Environment->pixmap_path)+1) ; sprintf( envp[slot_no], "%s=%s", ASIMAGE_PATH_ENVVAR, Environment->pixmap_path ); } if( Environment->font_path ) { int slot_no = font_path_slot ; if( slot_no < 0 ) slot_no = env_s++ ; envp[slot_no] = safemalloc(strlen( ASFONT_PATH_ENVVAR ) + 1 + strlen(Environment->font_path)+1) ; sprintf( envp[slot_no], "%s=%s", ASFONT_PATH_ENVVAR, Environment->font_path ); } } len = strlen((char*)cmd); if( pass_args ) { register int i = 0 ; while( display[i] ) ++i; while( i > 0 && isdigit(display[--i]) ); if( display[i] == '.' ) display[i+1] = '\0' ; /* This bit of code seems to break AS restarting on Fedora 8. causing DISPLAY=":0.0" to become DISPLAY=":0.". -- Jeremy */ if( screen >= 0 ) screen_str = string_from_int( screen ); if( w != None ) w_str = string_from_int( w ); if( context != C_NO_CONTEXT ) context_str = string_from_int( context ); len += 1+2+1+strlen( orig_display?orig_display:display ); if( screen_str ) len += strlen(screen_str); len += 3 ; /* for "-s " */ if ( get_flags( as_app_args.flags, ASS_Debugging) ) len += 8 ; if ( get_flags( as_app_args.flags, ASS_Restarting) ) len += 3 ; if ( as_app_args.override_config ) len += 4+strlen(as_app_args.override_config); if ( as_app_args.override_home ) len += 4+strlen(as_app_args.override_home); if ( as_app_args.override_share ) len += 4+strlen(as_app_args.override_share); if ( as_app_args.locale ) len += 4+strlen(as_app_args.locale); if( as_app_args.verbosity_level != OUTPUT_DEFAULT_THRESHOLD ) len += 4+32 ; #ifdef DEBUG_TRACE_X if( as_app_args.trace_calls ) len += 13+strlen( as_app_args.trace_calls ); #endif if( w_str ) len += 1+8+1+strlen(w_str); if( context_str ) len += 1+9+1+strlen(context_str); } /* now we want to append arbitrary number of arguments to the end of command line : */ va_start( ap, pass_args ); while( (arg = va_arg(ap,char*)) != NULL ) len += 1+strlen(arg); va_end(ap); len+=4; ptr = cmdl = safemalloc( len ); strcpy( cmdl, (char*)cmd ); while(*ptr) ptr++; if( pass_args ) { if (orig_display) ptr += sprintf( ptr, " -d %s -s", orig_display ); else ptr += sprintf( ptr, " -d %s%s -s", display, screen_str?screen_str:"" ); if ( get_flags( as_app_args.flags, ASS_Debugging) ) { strcpy( ptr, " --debug"); ptr+=8 ; } if ( get_flags( as_app_args.flags, ASS_Restarting) ) { strcpy( ptr, " -r"); ptr += 3 ; } if ( as_app_args.override_config ) ptr += sprintf( ptr, " -f %s", as_app_args.override_config ); if ( as_app_args.override_home ) ptr += sprintf( ptr, " -p %s", as_app_args.override_home ); if ( as_app_args.override_share ) ptr += sprintf( ptr, " -g %s", as_app_args.override_share ); if( as_app_args.verbosity_level != OUTPUT_DEFAULT_THRESHOLD ) ptr += sprintf( ptr, " -V %d", as_app_args.verbosity_level ); LOCAL_DEBUG_OUT( "len = %d, cmdl = \"%s\" strlen = %d, locale = \"%s\", ptr-cmdl = %d", len, cmdl, (int)strlen(cmdl), as_app_args.locale, (int)(ptr-cmdl) ); if( as_app_args.locale && as_app_args.locale[0] && !isspace(as_app_args.locale[0])) ptr += sprintf( ptr, " -L %s", as_app_args.locale ); #ifdef DEBUG_TRACE_X if( as_app_args.trace_calls ) ptr += sprintf( ptr, " --trace-func %s", as_app_args.trace_calls ); #endif if( w_str ) ptr += sprintf( ptr, " --window %s", w_str ); if( context_str ) ptr += sprintf( ptr, " --context %s", context_str ); } va_start( ap, pass_args ); while( (arg = va_arg(ap,char*)) != NULL ) { *(ptr++) = ' '; strcpy( ptr, arg ); while(*ptr) ptr++; LOCAL_DEBUG_OUT( "len = %d, cmdl = \"%s\" strlen = %d", len, cmdl, (int)strlen(cmdl) ); } va_end(ap); if( do_fork ) { int i = ptr-cmdl; while( --i >= 0 ) if( !isspace(cmdl[i]) ) break; do_fork = ( i < 0 || cmdl[i] != '&' ); } strcpy (ptr, do_fork?" &\n":"\n"); LOCAL_DEBUG_OUT( "len = %d, cmdl = \"%s\" strlen = %d", len, cmdl, (int)strlen(cmdl) ); #if defined(LOCAL_DEBUG) && !defined(NO_DEBUG_OUTPUT) { FILE *fff = fopen ("/tmp/afterstep.exec.log", "a"); if( fff ) { fprintf( fff, "%s:%ld: [%s]", MyName, time(NULL), cmdl ); fclose(fff); } } #endif LOCAL_DEBUG_OUT("execle(\"%s\")", cmdl ); /* fprintf( stderr, "len=%d: execl(\"%s\")", len, cmdl ); */ /* CYGWIN does not handle close-on-exec gracefully - whave to do it ourselves : */ if( CloseOnExec ) CloseOnExec(); { const char *shell; char *argv0 ; if ((shell = getenv("SHELL")) == NULL || *shell == '\0') shell = mystrdup("/bin/sh"); parse_file_name(shell, NULL, &argv0); /* argv0 = basename(shell); */ execle (shell, argv0 , "-c", cmdl, (char *)0, envp); } if( screen >= 0 ) show_error( "failed to start %s on the screen %d", cmd, screen ); else show_error( "failed to start %s", cmd ); show_system_error( " complete command line: \"%s\"\n", cmdl ); exit(128); } }
uint8 ArchDrive::open_file(int channel, const uint8 *name, int name_len) { uint8 plain_name[NAMEBUF_LENGTH]; int plain_name_len; int mode = FMODE_READ; int type = FTYPE_DEL; int rec_len = 0; parse_file_name(name, name_len, plain_name, plain_name_len, mode, type, rec_len); // Channel 0 is READ, channel 1 is WRITE if (channel == 0 || channel == 1) { mode = channel ? FMODE_WRITE : FMODE_READ; if (type == FTYPE_DEL) type = FTYPE_PRG; } bool writing = (mode == FMODE_WRITE || mode == FMODE_APPEND); // Wildcards are only allowed on reading if (writing && (strchr((const char *)plain_name, '*') || strchr((const char *)plain_name, '?'))) { set_error(ERR_SYNTAX33); return ST_OK; } // Allow only read accesses if (writing) { set_error(ERR_WRITEPROTECT); return ST_OK; } // Relative files are not supported if (type == FTYPE_REL) { set_error(ERR_UNIMPLEMENTED); return ST_OK; } // Find file int num; if (find_first_file(plain_name, plain_name_len, num)) { // Open temporary file if ((file[channel] = tmpfile()) != NULL) { // Write load address (.t64 only) if (archive_type == TYPE_T64) { fwrite(&file_info[num].sa_lo, 1, 1, file[channel]); fwrite(&file_info[num].sa_hi, 1, 1, file[channel]); } // Copy file contents from archive file to temp file uint8 *buf = new uint8[file_info[num].size]; fseek(the_file, file_info[num].offset, SEEK_SET); fread(buf, file_info[num].size, 1, the_file); fwrite(buf, file_info[num].size, 1, file[channel]); rewind(file[channel]); delete[] buf; if (mode == FMODE_READ) // Read and buffer first byte read_char[channel] = getc(file[channel]); } } else set_error(ERR_FILENOTFOUND); return ST_OK; }