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);
}
}
