void exit_tmp( void ) { int eax; int error; char tmp[2048]; DIR *dir; if ( TMPDIR[0] == 0 ) TMPCLEAN = 1; else if ( TMPCLEAN == 0 ) { chdir( CWD ); sprintf( tmp, "rm -rf %s/*", TMPDIR ); if ( VERBOSE ) fwrite( "Removing temporary extension files...", 1, 37, stdout ); error = system( tmp ); sprintf( tmp, "rmdir %s", TMPDIR ); error = system( tmp ); dir = opendir( TMPDIR ); if ( dir ) print_warning( "could not remove temporary directory %s.\nPlease remove manually.\n", TMPDIR[0] ); if ( VERBOSE ) print_done( ); TMPCLEAN = 1; } return; }
int source_clean( char *package ) { char dir[2048]; char sysstr[2048]; int error; sprintf( dir, "%s/src", basename( package ) ); error = chdir( dir ); if ( error < 0 ) print_error( -2, "extension '%s' not accessible: ", package ); if ( VERBOSE ) { fprintf( stdout, "Running '%s clean':\n", MAKE_CMD ); sprintf( sysstr, "%s -f Makefile clean", MAKE_CMD ); error = system( sysstr ); } else { fwrite( "Cleaning up...", 1, 14, stdout ); sprintf( sysstr, "%s -f Makefile -s clean &> %s", MAKE_CMD, TMP_NULL ); error = system( sysstr ); } if ( error == -1 ) print_error( -9, "could not run '%s clean' do you have make tools installed?\n", MAKE_CMD[0] ); else print_done( ); system( "sh ../post" ); return 0; }
void restore( char *gisbase, char *grass_version ) { int num_restored; char tmp[2048]; char *verstr = strdup( grass_version ); char *grass_major = strtok( verstr, "." ); char *grass_minor = strtok( 0, "." ); char *grass_revision = strtok( 0, "." ); int major = strtol( grass_major, 0, 10 ), minor = strtol( grass_minor, 0, 10 ), revision = strtol( grass_revision, 0, 10 ); free( verstr ); fwrite( "Restoring...", 1, 12, stdout ); if ( major == 6 && minor <= 0 ) { num_restored = restore_entries_gisman( gisbase ); if ( VERBOSE ) fprintf( stdout, "\nRestored entries for GIS Manager: %i\n", num_restored ); } num_restored = restore_html( gisbase ); if ( VERBOSE ) fprintf( stdout, "\nRestored links in index.hml: %i\n", num_restored ); if ( num_restored > 0 ) { if ( VERBOSE ) sprintf( tmp, "cp -f %s %s/etc/dm/menu.tcl ; chmod a+r %s/etc/dm/menu.tcl ; \t\t\t\t\t\t\tcp -f %s %s/docs/html/index.html ; chmod a+r %s/docs/html/index.html", TMP_GISMAN, gisbase, gisbase, TMP_HTML, gisbase, gisbase ); else sprintf( tmp, "cp -f %s %s/etc/dm/menu.tcl ; chmod a+r %s/etc/dm/menu.tcl &> %s ; \t\t\t\t\t\t\tcp -f %s %s/docs/html/index.html ; chmod a+r %s/docs/html/index.html", TMP_GISMAN, gisbase, gisbase, TMP_NULL, TMP_HTML, gisbase, gisbase ); su( gisbase, tmp ); } if ( num_restored == 0 ) print_error( -26, "could not find anything to restore.\n" ); else print_done( ); return; }
void check_extension( char *package, char *name, int *major, int *minor, int *revision ) { int error; char tmp[2048]; FILE *f; *(int*)&tmp[0] = 0; memset( &tmp[4], 0, 2044 ); fwrite( "Checking extension ...", 1, 22, stdout ); strcpy( tmp, package ); error = chdir( tmp ); if ( error < 0 ) { print_error( -2, "extension '%s' not accessible: %s\n", package, strerror( *(int*)(__errno_location( )) ) ); } f = (FILE*)fopen( "id", "r" ); if ( f == 0 ) print_error( -6, "'id' file not readable.\n" ); else { __isoc99_fscanf( f, "%[<GRASS extension package>] ", &tmp ); if ( strcmp( "<GRASS extension package>", tmp ) ) { fclose( f ); print_error( -6, "unknown file identifier.\n" ); } } fclose( f ); get_package_name( ".", name ); f = (FILE*)fopen( "version", "r" ); if ( f == 0 ) print_error( -6, "'version' file not readable.\n" ); else { nc_fgets_nb( tmp, 2048, f ); minor[0] = 0; revision[0] = 0; error = __isoc99_sscanf( tmp, "%i.%i.%i", major, minor, revision ); if ( error <= 0 ) { fclose( f ); print_error( -6, "invalid or missing version information.\n" ); } } print_done( ); chdir( ".." ); fclose( f ); return; }
static void handle_verify(const quvi_word type) { rand_decor(); if (type == QUVISTATUSTYPE_DONE) print_done(); }
void exit_db( void ) { int eax; int error; char tmp[2048]; if ( TMPDBCLEAN == 0 ) { chdir( CWD ); if ( VERBOSE ) fwrite( "Removing temporary registration files...", 1, 40, stdout ); if ( TMPDB[0] ) { sprintf( tmp, "rm -rf %s", TMPDB ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMPDB[0] ); } if ( TMP_GISMAN[0] ) { sprintf( tmp, "rm -f %s", TMP_GISMAN ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMP_GISMAN[0] ); } if ( TMP_DESCR[0] ) { sprintf( tmp, "rm -f %s", TMP_DESCR ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMP_DESCR[0] ); } if ( TMP_INFO[0] ) { sprintf( tmp, "rm -f %s", TMP_INFO ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMP_INFO[0] ); } if ( TMP_DEPS[0] ) { sprintf( tmp, "rm -f %s", TMP_DEPS ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMP_INFO[0] ); } if ( TMP_BUGS[0] ) { sprintf( tmp, "rm -f %s", TMP_BUGS ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMP_INFO[0] ); } if ( TMP_AUTHORS[0] ) { sprintf( tmp, "rm -f %s", TMP_AUTHORS ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMP_INFO[0] ); } if ( TMP_HTML[0] ) { sprintf( tmp, "rm -f %s", TMP_HTML ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMP_HTML[0] ); } if ( VERBOSE == 0 && TMP_NULL[0] ) { sprintf( tmp, "rm -f %s", TMP_NULL ); error = system( tmp ); if ( error ) print_warning( "could not remove temporary file %s.\nPlease remove manually.\n", TMP_NULL[0] ); } if ( VERBOSE ) print_done( ); TMPDBCLEAN = 1; } return; }
/** The get-recrod command */ int cmd_get_record (int argc, const char *argv[]) { if (OPTIONS.tenant[0] == 0) { fprintf (stderr, "%% No tenantid provided\n"); return 1; } if (OPTIONS.host[0] == 0) { fprintf (stderr, "%% No hostid provided\n"); return 1; } var *apires = api_get ("/%s/host/%s", OPTIONS.tenant, OPTIONS.host); if (OPTIONS.json) { var_dump (apires, stdout); var_free (apires); return 0; } #define Arr(x) var_get_array_forkey(apires,x) #define Vint(x) var_get_int_forkey(apires,x) #define Vstr(x) var_get_str_forkey(apires,x) #define Vfrac(x) var_get_double_forkey(apires,x) #define VDint(x,y) var_get_int_forkey(var_get_dict_forkey(apires,x),y) #define VDstr(x,y) var_get_str_forkey(var_get_dict_forkey(apires,x),y) #define VDfrac(x,y) var_get_double_forkey(var_get_dict_forkey(apires,x),y) #define VAfrac(x,y) var_get_double_atindex(var_get_array_forkey(apires,x),y) #define Vdone(x) var_delete_key(apires,x) /* -------------------------------------------------------------*/ print_hdr ("HOST"); print_value ("UUID", "%s", OPTIONS.host); print_value ("Hostname", "%s", Vstr("hostname")); print_value ("Address", "%s", VDstr("agent","ip")); print_value ("Status", "\033[1m%s\033[0m", Vstr("status")); print_array ("Problems", Arr("problems")); Vdone("hostname"); Vdone("agent"); Vdone("status"); Vdone("problems"); char uptimestr[128]; uint64_t uptime = Vint("uptime"); Vdone("uptime"); uint64_t u_days = uptime / 86400ULL; uint64_t u_hours = (uptime - (86400 * u_days)) / 3600ULL; uint64_t u_mins = (uptime - (86400 * u_days) - (3600 * u_hours)) / 60ULL; uint64_t u_sec = uptime % 60; if (u_days) { sprintf (uptimestr, "%llu day%s, %llu:%02llu:%02llu", u_days, (u_days==1)?"":"s", u_hours, u_mins, u_sec); } else if (u_hours) { sprintf (uptimestr, "%llu:%02llu:%02llu", u_hours, u_mins, u_sec); } else { sprintf (uptimestr, "%llu minute%s, %llu second%s", u_mins, (u_mins==1)?"":"s", u_sec, (u_sec==1)?"":"s"); } print_value ("Uptime","%s",uptimestr); print_value ("OS/Hardware","%s %s (%s)", VDstr("os","kernel"), VDstr("os","version"), VDstr("os","arch")); const char *dist = VDstr("os","distro"); if (dist) print_value ("Distribution", "%s", dist); Vdone("os"); /* -------------------------------------------------------------*/ print_hdr ("RESOURCES"); print_value ("Processes","\033[1m%llu\033[0m " "(\033[1m%llu\033[0m running, " "\033[1m%llu\033[0m stuck)", VDint("proc","total"), VDint("proc","run"), VDint("proc","stuck")); Vdone("proc"); print_value ("Load Average", "\033[1m%6.2f\033[0m / " "\033[1m%6.2f\033[0m / " "\033[1m%6.2f\033[0m", VAfrac ("loadavg",0), VAfrac ("loadavg", 1), VAfrac ("loadavg",2)); Vdone ("loadavg"); char cpubuf[128]; sprintf (cpubuf, "\033[1m%6.2f \033[0m%%", Vfrac("pcpu")); char meter[32]; strcpy (meter, "-[ ]+"); double iowait = VDfrac("io","pwait"); double pcpu = Vfrac("pcpu"); Vdone("pcpu"); double level = 4.5; int pos = 2; while (level < 100.0 && pos < 22) { if (level < pcpu) meter[pos++] = '#'; else meter[pos++] = ' '; level += 4.5; } print_value ("CPU", "%-40s %s", cpubuf, meter); if (iowait>0.001) print_value ("CPU iowait", "\033[1m%6.2f %%\033[0m", iowait); print_value ("Available RAM", "\033[1m%.2f\033[0m MB", ((double)VDint("mem","total"))/1024.0); print_value ("Free RAM", "\033[1m%.2f\033[0m MB", ((double)VDint("mem","free"))/1024.0); print_value ("Network in/out", "\033[1m%i\033[0m Kb/s " "(\033[1m%i\033[0m pps) / " "\033[1m%i\033[0m Kb/s " "(\033[1m%i\033[0m pps)", VDint("net","in_kbs"), VDint("net","in_pps"), VDint("net","out_kbs"), VDint("net","out_pps")); print_value ("Disk i/o", "\033[1m%i\033[0m rdops / " "\033[1m%i\033[0m wrops", VDint("io","rdops"), VDint("io","wrops")); Vdone("mem"); Vdone("net"); Vdone("io"); Vdone("badness"); print_values (apires, NULL); /* -------------------------------------------------------------*/ print_hdr ("PROCESS LIST"); const char *top_hdr[] = {"USER","PID","CPU","MEM","NAME",NULL}; const char *top_fld[] = {"user","pid","pcpu","pmem","name",NULL}; columnalign top_align[] = {CA_L, CA_R, CA_R, CA_R, CA_L, CA_NULL}; vartype top_tp[] = {VAR_STR,VAR_INT,VAR_DOUBLE,VAR_DOUBLE,VAR_STR,VAR_NULL}; int top_wid[] = {15, 7, 9, 9, 0, 0}; int top_div[] = {0, 0, 0, 0, 0, 0}; const char *top_suf[] = {"",""," %", " %", "", NULL}; var *v_top = var_get_array_forkey (apires, "top"); print_table (v_top, top_hdr, top_fld, top_align, top_tp, top_wid, top_suf, top_div); Vdone("top"); /* -------------------------------------------------------------*/ print_hdr ("STORAGE"); const char *df_hdr[] = {"DEVICE","SIZE","FS","USED","MOUNTPOINT",NULL}; const char *df_fld[] = {"device","size","fs","pused","mount",NULL}; columnalign df_aln[] = {CA_L,CA_R,CA_L,CA_R,CA_L,CA_NULL}; vartype df_tp[] = {VAR_STR,VAR_INT,VAR_STR,VAR_DOUBLE,VAR_STR,VAR_NULL}; int df_wid[] = {12, 14, 6, 8, 0}; int df_div[] = {0, (1024), 0, 0, 0, 0}; const char *df_suf[] = {""," GB", "", " %", "", ""}; var *v_df = var_get_array_forkey (apires, "df"); /*print_generic_table (v_df);*/ print_table (v_df, df_hdr, df_fld, df_aln, df_tp, df_wid, df_suf, df_div); Vdone("df"); /** Print any remaining table data */ print_tables (apires); printf ("---------------------------------------------" "-----------------------------------\n"); var_free (apires); print_done(); return 0; }
void uninstall( char *package, char *pkg_short_name, char *gisbase, char *grass_version ) { char tmp[2048]; char script[2048]; int error; struct stat buf; int no_script; char *verstr; char *grass_major; char *grass_minor; char *grass_revision; int major, minor, revision; fwrite( "Un-installing...", 1, 16, stdout ); sprintf( UNINSTALL_BASE, "UNINSTALL_BASE=%s", gisbase ); putenv( UNINSTALL_BASE ); verstr = strdup( grass_version ); grass_major = strtok( verstr, "." ); grass_minor = strtok( 0, "." ); grass_revision = strtok( 0, "." ); major = strtol( grass_major, 0, 10 ); minor = strtol( grass_minor, 0, 10 ); revision = strtol( grass_revision, 0, 10 ); free( verstr ); atexit( &exit_tmp ); deregister_extension( package, pkg_short_name, gisbase ); if ( major == 6 && minor <= 0 ) { error = deregister_entries_gisman( pkg_short_name, gisbase ); if ( error == -1 ) { print_warning( "GIS Manager menu entries could not be removed.\n" ); memcpy( GISMAN_CMD, "", 1 ); } if ( error == 0 ) { print_warning( "no entries found to remove from GIS Manager.\n" ); memcpy( GISMAN_CMD, "", 1 ); } } deregister_entries_gisman2( pkg_short_name, gisbase ); deregister_html( pkg_short_name, gisbase ); sprintf( script, "%s/etc/uninstall.%s", gisbase, pkg_short_name ); no_script = 0; error = stat( script, &buf.st_dev ); if ( error < 0 ) { print_warning( "no uninstall script available for this extension.\n \t\t\tUnneeded files may have been left on your system.\n" ); no_script = 1; } if ( no_script ) { print_warning( "error checking for uninstall script: %s\n \t\t\t\tUninstalling this extension may leave orphaned files on your system", strerror( *(int*)(__errno_location( )) ) ); } else if ( VERBOSE ) { sprintf( tmp, "sh %s ; rm -vf %s ; \t\t\t\t\t \t\trm -vrf %s/docs/extensions/%s ; rm -vf %s/etc/dm/gem-entries/%s ; \t\t\t\t\t\t\tcp -vf %s %s/etc/extensions.db ; chmod -v a+r %s/etc/extensions.db ;", script, script, gisbase, pkg_short_name, gisbase, pkg_short_name, TMPDB, gisbase, gisbase ); strcpy( UNINSTALL_CMD, tmp ); } else { sprintf( tmp, "sh %s &> %s ; rm -vf %s &> %s ; \t\t\t\t\t \t\trm -vrf %s/docs/extensions/%s &> %s ; rm -vf %s/etc/dm/gem-entries/%s &> %s ; \t\t\t\t\t\t\tcp -vf %s %s/etc/extensions.db &> %s ; chmod -v a+r %s/etc/extensions.db &> %s ;", script, TMP_NULL, script, TMP_NULL, gisbase, pkg_short_name, TMP_NULL, gisbase, pkg_short_name, TMP_NULL, TMPDB, gisbase, TMP_NULL, gisbase, TMP_NULL ); strcpy( UNINSTALL_CMD, tmp ); } sprintf( tmp, "%s %s %s", UNINSTALL_CMD, GISMAN_CMD, HTML_CMD ); su( gisbase, tmp ); print_done( ); return; }
void unpack_extension( char *package ) { int error; int fd; char tmp[2048]; int ftype; fwrite( "Uncompressing files...", 1, 22, stdout ); memcpy( TMPDIR, "/tmp/grass.extension.XXXXXX", 28 ); mkstemp( TMPDIR ); fd = open( TMPDIR, 64, 511 ); if ( fd == -1 ) { print_error( -7, "could not create temp directory name: %s", strerror( *(int*)(__errno_location( )) ) ); exit( -7 ); } if ( VERBOSE ) fprintf( stdout, "\nUncompressing to: %s.\n", TMPDIR ); close( fd ); remove( TMPDIR ); mkdir_s( TMPDIR, "0700" ); atexit( &exit_tmp ); sprintf( tmp, "cp %s %s", package, TMPDIR ); error = system( tmp ); if ( error < 0 ) { print_error( -7, "could not copy extension files to temp dir.\n" ); exit( -7 ); } ftype = check_filetype( package ); if ( ftype == 0 ) { print_warning( "file name not '.tar.gz', '.tgz', '.tar.bz2', '.tbz' or '.zip'. Assuming '.tgz'.\n" ); ftype = 1; } if ( ftype == 1 ) { if ( VERBOSE ) { sprintf( tmp, "tar -xzvf %s/%s -C %s", TMPDIR, basename( package ), TMPDIR ); } else { sprintf( tmp, "tar -xzf %s/%s -C %s", TMPDIR, basename( package ), TMPDIR ); } } if ( ftype == 2 ) { if ( VERBOSE ) { sprintf( tmp, "tar -xjvf %s/%s -C %s", TMPDIR, basename( package ), TMPDIR ); } else { sprintf( tmp, "tar -xjvf %s/%s -C %s", TMPDIR, basename( package ), TMPDIR ); } } if ( ftype == 3 ) { if ( VERBOSE ) { sprintf( tmp, "unzip %s/%s -d %s", TMPDIR, basename( package ), TMPDIR ); } else { sprintf( tmp, "unzip -qq %s/%s -d %s", TMPDIR, basename( package ), TMPDIR ); } } if ( ftype == 4 ) { if ( VERBOSE ) { sprintf( tmp, "tar -xvf %s/%s -C %s", TMPDIR, basename( package ), TMPDIR ); } else { sprintf( tmp, "tar -xf %s/%s -C %s", TMPDIR, basename( package ), TMPDIR ); } } error = system( tmp ); if ( error < 0 ) { if ( ftype == 1 ) print_error( -7, "could not extract files using 'tar' and 'gzip'. \n \t\t\t\t\tExtract manually using 'tar -xzvf %s'.\n", package ); if ( ftype == 2 ) print_error( -7, "could not extract files using 'tar' and 'bunzip2'.\n \t\t\t\tExtract manually using 'tar -xjvf %s'.\n", package ); if ( ftype == 3 ) print_error( -7, "could not extract files using 'unzip'.\n \t\t\t\tExtract manually using 'unzip %s'.\n", package ); exit( -7 ); } else { print_done( ); return; } }
void test_install( char *package, char *gisbase, char *pkg_short_name, int pkg_major, int pkg_minor, int pkg_revision, char *grass_version ) { char tmp[2048]; char dir[2048]; char sysstr[2048]; int error = stat( gisbase, &buf.st_dev ); struct stat buf; FILE *f; char *verstr; char *grass_major; char *grass_minor; char *grass_revision; int major, minor, revision; if ( error < 0 ) { print_error( -5, "installation directory invalid: %s\n", strerror( *(int*)(__errno_location( )) ) ); } sprintf( GINSTALL_DST, "GINSTALL_DST=%s", gisbase ); putenv( GINSTALL_DST ); sprintf( tmp, "%s/include", gisbase ); sprintf( GINSTALL_INC, "GINSTALL_INC=%s", tmp ); putenv( GINSTALL_INC ); sprintf( tmp, "%s/lib", gisbase ); sprintf( GINSTALL_LIB, "GINSTALL_LIB=%s", tmp ); putenv( GINSTALL_LIB ); sprintf( GEM_GRASS_DIR, "GEM_GRASS_DIR=%s", gisbase ); putenv( GEM_GRASS_DIR ); verstr = strdup( grass_version ); grass_major = strtok( verstr, "." ); grass_minor = strtok( 0, "." ); grass_revision = strtok( 0, "." ); major = strtol( grass_major, 0, 10 ); minor = strtol( grass_minor, 0, 10 ); revision = strtol( grass_revision, 0, 10 ); free( verstr ); atexit( &exit_tmp ); sprintf( dir, "%s/src", basename( package ) ); error = chdir( dir ); if ( error < 0 ) { print_error( -2, "extension files in '%s' not accessible: %s\n", package, strerror( *(int*)(__errno_location( )) ) ); } if ( SKIP_CFG == 0 ) { if ( VERBOSE ) { fwrite( "Running configure script:\n", 1, 26, stdout ); sprintf( sysstr, "sh %s %s", CONFIG_CMD, CONFIG_OPTS ); error = system( sysstr ); } else { fwrite( "Configuring...", 1, 14, stdout ); sprintf( sysstr, "sh %s %s --quiet &> %s", CONFIG_CMD, CONFIG_OPTS, TMP_NULL ); error = system( sysstr ); } if ( error == -1 ) print_error( -27, "could not run configure script.\n" ); if ( error > 0 ) print_error( -3, "system configuration failed.\n" ); print_done( ); print_cfg( ); } sprintf( GEM_EXT_NAME, "GEM_EXT_NAME=%s", pkg_short_name ); putenv( GEM_EXT_NAME ); sprintf( tmp, "%i.%i.%i", pkg_major, pkg_minor, pkg_revision ); sprintf( GEM_EXT_VERSION, "GEM_EXT_VERSION=%s", tmp ); putenv( GEM_EXT_VERSION ); dump_plain( "../description", TMP_DESCR ); dump_plain( "../info", TMP_INFO ); dump_plain( "../depends", TMP_DEPS ); dump_plain( "../bugs", TMP_BUGS ); dump_plain( "../authors", TMP_AUTHORS ); sprintf( GEM_EXT_DESCR, "GEM_EXT_DESCR=%s", TMP_DESCR ); putenv( GEM_EXT_DESCR ); sprintf( GEM_EXT_INFO, "GEM_EXT_INFO=%s", TMP_INFO ); putenv( GEM_EXT_INFO ); sprintf( GEM_EXT_DEPS, "GEM_EXT_DEPS=%s", TMP_DEPS ); putenv( GEM_EXT_DEPS ); sprintf( GEM_EXT_BUGS, "GEM_EXT_BUGS=%s", TMP_BUGS ); putenv( GEM_EXT_BUGS ); sprintf( GEM_EXT_AUTHORS, "GEM_EXT_AUTHORS=%s", TMP_AUTHORS ); putenv( GEM_EXT_AUTHORS ); atexit( &exit_tmp ); check_dependencies( package, gisbase, grass_version ); if ( VERBOSE ) { fprintf( stdout, "Running '%s':\n", MAKE_CMD ); sprintf( sysstr, "%s -f Makefile", MAKE_CMD ); error = system( sysstr ); } else { fwrite( "Compiling...", 1, 12, stdout ); sprintf( sysstr, "%s -f Makefile &> %s", MAKE_CMD, TMP_NULL ); error = system( sysstr ); } if ( error == -1 && VERBOSE == 0 ) print_error( -9, "could not run '%s' do you have make tools installed?\n", MAKE_CMD[0] ); if ( error > 0 ) print_error( -4, "source code could not be compiled.\n \t\t\tRun again with option -v to see what is causing trouble.\n" ); print_done( ); fwrite( "Installing...", 1, 13, stdout ); f = (FILE*)fopen( "../uninstall", "r" ); if ( f == 0 ) { print_warning( "error checking for uninstall script: %s\n \t\t\t\tUninstalling this extension may leave orphaned files on your system", strerror( *(int*)(__errno_location( )) ) ); } else fclose( f ); register_extension( gisbase, "src", pkg_short_name, pkg_major, pkg_minor, pkg_revision ); check_dependencies( package, gisbase, grass_version ); if ( major == 6 && minor <= 0 ) register_entries_gisman( pkg_short_name, gisbase ); register_entries_gisman2( pkg_short_name, gisbase ); register_html( pkg_short_name, gisbase, pkg_major, pkg_minor, pkg_revision ); fprintf( stdout, "(skipping '%s install')...", MAKE_CMD ); print_done( ); return; }
void bin_install( char *package, char *gisbase, char *bins, char *pkg_short_name, int pkg_major, int pkg_minor, int pkg_revision, char *grass_version ) { char tmp[2048]; char dir[2048]; char install_cmd[2048]; char post_cmd[2048]; int error = stat( gisbase, &buf.st_dev ); struct stat buf; FILE *f; char *verstr; char *grass_major; char *grass_minor; char *grass_revision; int major, minor, revision; if ( error < 0 ) { print_error( -5, "installation directory invalid: %s\n", strerror( *(int*)(__errno_location( )) ) ); } sprintf( GINSTALL_DST, "GINSTALL_DST=%s", gisbase ); putenv( GINSTALL_DST ); sprintf( tmp, "%s/include", gisbase ); sprintf( GINSTALL_INC, "GINSTALL_INC=%s", tmp ); putenv( GINSTALL_INC ); sprintf( tmp, "%s/lib", gisbase ); sprintf( GINSTALL_LIB, "GINSTALL_LIB=%s", tmp ); putenv( GINSTALL_LIB ); sprintf( GEM_GRASS_DIR, "GEM_GRASS_DIR=%s", gisbase ); putenv( GEM_GRASS_DIR ); verstr = strdup( grass_version ); grass_major = strtok( verstr, "." ); grass_minor = strtok( 0, "." ); grass_revision = strtok( 0, "." ); major = strtol( grass_major, 0, 10 ); minor = strtol( grass_minor, 0, 10 ); revision = strtol( grass_revision, 0, 10 ); free( verstr ); atexit( &exit_tmp ); sprintf( dir, "%s/%s", basename( package ), bins ); error = chdir( dir ); if ( error < 0 ) { print_error( -2, "extension file binaries in '%s' not accessible: %s\n", package, strerror( *(int*)(__errno_location( )) ) ); } sprintf( GEM_EXT_NAME, "GEM_EXT_NAME=%s", pkg_short_name ); putenv( GEM_EXT_NAME ); sprintf( tmp, "%i.%i.%i", pkg_major, pkg_minor, pkg_revision ); sprintf( GEM_EXT_VERSION, "GEM_EXT_VERSION=%s", tmp ); putenv( GEM_EXT_VERSION ); dump_html( "../description", TMP_DESCR ); dump_html( "../info", TMP_INFO ); dump_html( "../depends", TMP_DEPS ); dump_html( "../bugs", TMP_BUGS ); dump_html( "../authors", TMP_AUTHORS ); sprintf( GEM_EXT_DESCR, "GEM_EXT_DESCR=%s", TMP_DESCR ); putenv( GEM_EXT_DESCR ); sprintf( GEM_EXT_INFO, "GEM_EXT_INFO=%s", TMP_INFO ); putenv( GEM_EXT_INFO ); sprintf( GEM_EXT_DEPS, "GEM_EXT_DEPS=%s", TMP_DEPS ); putenv( GEM_EXT_DEPS ); sprintf( GEM_EXT_BUGS, "GEM_EXT_BUGS=%s", TMP_BUGS ); putenv( GEM_EXT_BUGS ); sprintf( GEM_EXT_AUTHORS, "GEM_EXT_AUTHORS=%s", TMP_AUTHORS ); putenv( GEM_EXT_AUTHORS ); atexit( &exit_tmp ); check_dependencies( package, gisbase, grass_version ); fwrite( "Installing...", 1, 13, stdout ); f = (FILE*)fopen( "../uninstall", "r" ); if ( f == 0 ) { print_warning( "error checking for uninstall script: %s\n \t\t\t\tUninstalling this extension may leave orphaned files on your system", strerror( *(int*)(__errno_location( )) ) ); } else { if ( VERBOSE ) { sprintf( tmp, "cp -vf ../uninstall %s/etc/uninstall.%s ;", gisbase, pkg_short_name ); strcpy( UNINSTALL_CMD, tmp ); } else { sprintf( tmp, "cp -f ../uninstall %s/etc/uninstall.%s &> %s ;", gisbase, pkg_short_name, TMP_NULL ); strcpy( UNINSTALL_CMD, tmp ); } fclose( f ); } register_extension( gisbase, bins, pkg_short_name, pkg_major, pkg_minor, pkg_revision ); check_dependencies( package, gisbase, grass_version ); if ( major == 6 && minor <= 0 ) register_entries_gisman( pkg_short_name, gisbase ); register_entries_gisman2( pkg_short_name, gisbase ); register_html( pkg_short_name, gisbase, pkg_major, pkg_minor, pkg_revision ); if ( VERBOSE ) { fprintf( stdout, "Running '%s install':\n", MAKE_CMD ); sprintf( install_cmd, "bin/%s -f Makefile install ; \t\t\t\t\tcp -vf %s %s/etc/extensions.db ; chmod -v a+r %s/etc/extensions.db ;", MAKE_CMD, TMPDB, gisbase, gisbase ); } else sprintf( install_cmd, "bin/%s -f Makefile -s install &> %s ; \t\t\t\t\tcp -f %s %s/etc/extensions.db &> %s ; chmod a+r %s/etc/extensions.db &> %s ;", MAKE_CMD, TMP_NULL, TMPDB, gisbase, TMP_NULL, gisbase, TMP_NULL ); if ( VERBOSE ) memcpy( post_cmd, "sh ../post", 11 ); else sprintf( post_cmd, "sh ../post &> %s", TMP_NULL ); sprintf( tmp, "%s %s %s %s %s %s", install_cmd, UNINSTALL_CMD, GISMAN_CMD, GISMAN2_CMD, HTML_CMD, post_cmd ); su( gisbase, tmp ); print_done( ); return; }
void print_human(const struct params *prm, const struct usbmon_packet_1 *ep, const unsigned char *data, uint64_t start_sec) { struct print_cursor pcur; char udir, utype; int data_len, i; int ndesc; /* Display this many */ const struct usbmon_isodesc *dp; int cnt; ssize_t rc; print_start(&pcur, prm->print_buf, prm->print_size); if ((data_len = ep->len_cap) < 0) { /* Overflow */ data_len = 0; } #if 0 enum { TAG_BUF_SIZE = 17 }; char tag_buf[TAG_BUF_SIZE]; print_human_tag(tag_buf, TAG_BUF_SIZE, prm->tagp, ep); #endif /* * We cast into a truncated type for readability. * The danger of collisions is negligible. */ print_safe(&pcur, "%08x", (unsigned int) ep->id); udir = ((ep->epnum & 0x80) != 0) ? 'i' : 'o'; switch (ep->xfer_type & 0x3) { case PIPE_ISOCHRONOUS: utype = 'Z'; break; case PIPE_INTERRUPT: utype = 'I'; break; case PIPE_CONTROL: utype = 'C'; break; default: /* PIPE_BULK */ utype = 'B'; } print_safe(&pcur, " %u.%06u %c %c%c:%u:%03u:%u", (unsigned int)(ep->ts_sec - start_sec), ep->ts_usec, ep->type, utype, udir, ep->busnum, ep->devnum, ep->epnum & 0x7f); if (ep->type == 'E') { print_safe(&pcur, " %d", ep->status); } else { if (ep->flag_setup == 0) { /* Setup packet is present and captured */ print_safe(&pcur, " s %02x %02x %04x %04x %04x", ep->s.setup[0], ep->s.setup[1], (ep->s.setup[3] << 8) | ep->s.setup[2], (ep->s.setup[5] << 8) | ep->s.setup[4], (ep->s.setup[7] << 8) | ep->s.setup[6]); } else if (ep->flag_setup != '-') { /* Unable to capture setup packet */ print_safe(&pcur, " %c __ __ ____ ____ ____", ep->flag_setup); } else { /* No setup for this kind of URB */ if (ep->type == 'S' && ep->status == -EINPROGRESS) { print_safe(&pcur, " -"); } else { print_safe(&pcur, " %d", ep->status); } if (usb_typeisoc(ep->xfer_type) || usb_typeint(ep->xfer_type)) { print_safe(&pcur, ":%d", ep->interval); } if (usb_typeisoc(ep->xfer_type)) { print_safe(&pcur, ":%d", ep->start_frame); if (ep->type == 'C') { print_safe(&pcur, ":%d", ep->s.iso.error_count); } } } if (usb_typeisoc(ep->xfer_type)) { /* * This is the number of descriptors used by HC. */ print_safe(&pcur, " %d", ep->s.iso.numdesc); /* * This is the number of descriptors which we print. */ ndesc = ep->ndesc; if (ndesc > ISODESC_MAX) ndesc = ISODESC_MAX; if (ndesc * sizeof(struct usbmon_isodesc) > data_len) { ndesc = data_len / sizeof(struct usbmon_isodesc); } /* This is aligned by malloc */ dp = (struct usbmon_isodesc *) data; for (i = 0; i < ndesc; i++) { print_safe(&pcur, " %d:%u:%u", dp->iso_stat, dp->iso_off, dp->iso_len); dp++; } /* * The number of descriptors captured is used to * find where the data starts. */ ndesc = ep->ndesc; if (ndesc * sizeof(struct usbmon_isodesc) > data_len) { data_len = 0; } else { data += ndesc * sizeof(struct usbmon_isodesc); data_len -= ndesc * sizeof(struct usbmon_isodesc); } } } print_safe(&pcur, " %d", ep->length); if (ep->length > 0) { if (ep->flag_data == 0) { print_safe(&pcur, " =\n"); if (data_len >= prm->data_max) data_len = prm->data_max; print_human_data(&pcur, ep, data, data_len); } else { print_safe(&pcur, " %c\n", ep->flag_data); } } else { print_safe(&pcur, "\n"); } cnt = print_done(&pcur); if ((rc = write(1, prm->print_buf, cnt)) < cnt) { if (rc < 0) { fprintf(stderr, TAG ": Write error: %s\n", strerror(errno)); } else { fprintf(stderr, TAG ": Short write\n"); } exit(1); } }
void print_48(const struct params *prm, const struct usbmon_packet *ep, const unsigned char *data) { struct print_cursor pcur; char udir, utype; int data_len, i; int cnt; ssize_t rc; print_start(&pcur, prm->print_buf, prm->print_size); udir = ((ep->epnum & 0x80) != 0) ? 'i' : 'o'; switch (ep->xfer_type & 0x3) { case PIPE_ISOCHRONOUS: utype = 'Z'; break; case PIPE_INTERRUPT: utype = 'I'; break; case PIPE_CONTROL: utype = 'C'; break; default: /* PIPE_BULK */ utype = 'B'; } print_safe(&pcur, "%llx %u %c %c%c:%03u:%02u", (long long) ep->id, (unsigned int)(ep->ts_sec & 0xFFF) * 1000000 + ep->ts_usec, ep->type, utype, udir, ep->devnum, ep->epnum & 0x7f); if (ep->flag_setup == 0) { /* Setup packet is present and captured */ print_safe(&pcur, " s %02x %02x %04x %04x %04x", ep->setup[0], ep->setup[1], (ep->setup[3] << 8) | ep->setup[2], (ep->setup[5] << 8) | ep->setup[4], (ep->setup[7] << 8) | ep->setup[6]); } else if (ep->flag_setup != '-') { /* Unable to capture setup packet */ print_safe(&pcur, " %c __ __ ____ ____ ____", ep->flag_setup); } else { /* No setup for this kind of URB */ print_safe(&pcur, " %d", ep->status); } print_safe(&pcur, " %d", ep->length); if (ep->length > 0) { if (ep->flag_data == 0) { print_safe(&pcur, " ="); if ((data_len = ep->len_cap) >= DATA_MAX) data_len = DATA_MAX; for (i = 0; i < data_len; i++) { if (i % 4 == 0) { print_safe(&pcur, " "); } print_safe(&pcur, "%02x", data[i]); } print_safe(&pcur, "\n"); } else { print_safe(&pcur, " %c\n", ep->flag_data); } } else { print_safe(&pcur, "\n"); } cnt = print_done(&pcur); if ((rc = write(1, prm->print_buf, cnt)) < cnt) { if (rc < 0) { fprintf(stderr, TAG ": Write error: %s\n", strerror(errno)); } else { fprintf(stderr, TAG ": Short write\n"); } exit(1); } }