コード例 #1
0
ファイル: dltest.c プロジェクト: jvesely/helenos
int main(int argc, char *argv[])
{
	printf("Dynamic linking test\n");

	if (argc > 1) {
		if (argc > 2) {
			print_syntax();
			return 1;
		}

		if (str_cmp(argv[1], "-n") == 0) {
			no_dlfcn = true;
		} else {
			print_syntax();
			return 1;
		}
	}

	if (!no_dlfcn) {
		if (test_dlfcn() != 0)
			return 1;
	}

#ifdef DLTEST_LINKED
	if (test_lnk() != 0)
		return 1;
#endif

	printf("All passed.\n");
	return 0;
}
コード例 #2
0
ファイル: wifi_supplicant.c プロジェクト: jvesely/helenos
int main(int argc, char *argv[])
{
	int rc = inetcfg_init();
	if (rc != EOK) {
		printf("%s: Failed connecting to inetcfg service (%d).\n",
		    NAME, rc);
		return 1;
	}
	
	rc = dhcp_init();
	if (rc != EOK) {
		printf("%s: Failed connecting to dhcp service (%d).\n",
		    NAME, rc);
		return 1;
	}
	
	if (argc == 2) {
		if (!str_cmp(argv[1], "list"))
			return wifi_list();
	} else if (argc > 2) {
		uint32_t index;
		rc = str_uint32_t(argv[2], NULL, 10, false, &index);
		if (rc != EOK) {
			printf("%s: Invalid argument.\n", NAME);
			print_syntax();
			return EINVAL;
		}
		
		if (!str_cmp(argv[1], "scan")) {
			bool now = false;
			if (argc > 3)
				if (!str_cmp(argv[3], "-n"))
					now = true;
			
			return wifi_scan(index, now);
		} else if (!str_cmp(argv[1], "connect")) {
			char *pass = NULL;
			if (argc > 3) {
				if (argc > 4)
					pass = argv[4];
				
				return wifi_connect(index, argv[3], pass);
			}
		} else if (!str_cmp(argv[1], "disconnect"))
			return wifi_disconnect(index);
	}
	
	print_syntax();
	
	return EOK;
}
コード例 #3
0
ファイル: DU.C プロジェクト: OS2World/UTIL-DISK-DU-DF
/*************** MAIN PROGRAM ******************************/
int main(int arg_count, char **args)
{
  char startpath[_MAX_PATH], *apu;
  char *defaultdir = ".";
  unsigned long disk_size,disk_free, summa;
  double slack;

  printf("\nDU/" VERSION_BITS "bit v" VERSION_NO
	 "     Copyright (c) Timo Kokkonen, OH6LXV               "
	 RELEASE_DATE "\n\n");

  strcpy(startpath,".");
  if (arg_count>1) {
    if (!strcmp(args[1],"/?")) {
      print_syntax();
      exit(0);
    }
    if (args[arg_count-1][0]=='/')
     if (sscanf(&args[arg_count-1][1],"%d",&sublevels)!=1) {
       printf("\nInvalid parameter '%s'.\n",args[arg_count-1]);
       print_syntax();
       exit(1);
     }
  }
  if ((arg_count>=2)&&(args[1][0]!='/'))  apu=args[1];
    else apu=defaultdir;

  if (!_fullpath(startpath,apu,_MAX_PATH)) {
    printf("Cannot convert '%s' to absolute path.\n",apu);
    exit(1);
  }
  if (startpath[strlen(startpath)-1]!='\\') strcat(startpath,"\\");
  strcpy(startpath,SplitDir(startpath));

  if (!getDiskSize(startpath[0]-64,&disk_size,&disk_free,&cluster_size)) {
    printf("Cannot read drive %c: \n",startpath[0]);
    exit(1);
  }
  summa=calc_dir(startpath);
  if (true_sum!=0) slack=(1-(double)summa/true_sum)*100.0;
    else slack=0;

  // printf(" %lu  %lu  %lu \n",disk_size-disk_free,summa,true_sum);
  printf("\n %lu bytes in %lu file(s), %1.1lf%% slack (%lu bytes).\n",
							true_sum,
							file_counter,
							slack,
							true_sum-summa);
  return 0;
}
コード例 #4
0
ファイル: nterm.c プロジェクト: pratikmankawde/HelenOS_Nano
int main(int argc, char *argv[])
{
	kbd_event_t ev;
	int rc;

	if (argc != 3) {
		print_syntax();
		return 1;
	}

	rc = conn_open(argv[1], argv[2]);
	if (rc != EOK) {
		printf("Error connecting.\n");
		return 1;
	}

	printf("Connection established.\n");

	con = console_init(stdin, stdout);

	done = false;
	while (!done) {
		console_get_kbd_event(con, &ev);
		if (ev.type == KEY_PRESS)
			key_handle(&ev);
	}

	return 0;
}
コード例 #5
0
ファイル: write.c プロジェクト: radujipa/RPiSystemTimer
/*
 * A simple program to test the System Timer driver
 ******************************************************************************
 */
int main (int argc, char* argv[])
{
	const char *files[] = {"/dev/CS", "/dev/CLO", "/dev/CHI", "/dev/C0", "/dev/C1", "/dev/C2", "/dev/C3"} ;
	//const unsigned int file_count = sizeof (files) / sizeof (char*) ;

	/*  */
	if (argv[1] == NULL || argv[2] == NULL)
	{		
		print_syntax () ;
		exit (1) ;
	}

	/*  */
	int device_number = atoi(argv[1]) ;
	unsigned int write_value ;

	sscanf (atoi(argv[2]), "%u", &write_value) ;

	/*  */
	for (int repeat = 1 ; repeat <= 1 ; repeat++)
		write_to_device (files[device_number], &value) ;
	
	
  /* Program exists cleanly */
	return 0 ;
} //main
コード例 #6
0
ファイル: read.c プロジェクト: radujipa/RPiSystemTimer
/*
 * A simple program to test the System Timer driver
 ******************************************************************************
 */
int main (int argc, char* argv[])
{
	/*  */
	unsigned int read_value ;

	const char *files[] = {"/dev/CS", "/dev/CLO", "/dev/CHI", "/dev/C0", "/dev/C1", "/dev/C2", "/dev/C3"} ;
	const unsigned int file_count = sizeof (files) / sizeof (char*) ;

	/*  */
	if (argv[1] == NULL)
	{		
		print_syntax () ;
		exit (1) ;
	}

	if (strcmp(argv[1], "all") == 0)
	{
		for (int index = 0 ; index < file_count ; index++)
		  for (int repeat = 1 ; repeat <= 1 ; repeat++)
		  	read_from_device (files[index], &read_value) ;

	} // if

	/*  */
	else 
	{
		int index = atoi(argv[1]) ;
		read_from_device (files[index], &read_value) ;
	}
				
		
  /* Program exists cleanly */
	return 0 ;
} //main
コード例 #7
0
ファイル: main.c プロジェクト: claxclinton/Networking
int main(int argc, char **argv)
{
        int opt;
        int flag_description = 0;
        const char *address;

        opt = getopt(argc, argv, "d");
        if (opt == 'd')
        {
                argc--;
                argv++;
                flag_description = 1;
        }
        else if (opt != -1)
        {
                printf("\nUNKNOWN OPTION: -%c.\n\n", opt);
                print_syntax();
                return 1;
        }

        address = (argc == 1) ? NULL : argv[1];
        print_addr_info(address, flag_description);
        printf("\n");
        
        return 0;
}
コード例 #8
0
ファイル: cmdline.c プロジェクト: FDOS/ramdisk
static char *parse_arg(char *arg, int sw)
{
  struct switch_s *s = &switches[sw];

  if (s->parse)
    arg = s->parse(arg, s);
  else {
    switch(s->ID) {
    case SW_HELP:
      print_syntax();
      exit(0);
    case SW_OLD:
      use_old_format_f = YES;
      break;
    case SW_ERASE:
      defined_format |= CLEAR_DISK;
      forced_format |= CLEAR_DISK;
      break;
    case SPACE_AVAILABLE:
    case FILE_SPACE:
    case FREE_MEMORY:
    {
      unsigned long ln;
      char *next;

      ln = parse_kilobyte(arg, &next);
      if (arg == next)
        syntax("Argument expected for switch /%s", s->sw);
      arg = next;

      if (ln > 0x3FFFFFL)
        syntax(s->ID == FREE_MEMORY ? "Invalid available memory size"
                                    : "Invalid available disk size");

      *(dword *)s->loc = ln;
      defined_format |= s->ID;
      forced_format |= s->ID;
      break;
    }
    case SW_MINSIZE:
      *(dword *)s->loc = 0;
      defined_format |= SPACE_AVAILABLE;
      forced_format |= SPACE_AVAILABLE;
      break;
    case SW_MAXSIZE:
      *(dword *)s->loc = 0;
      defined_format |= FREE_MEMORY;
      forced_format |= FREE_MEMORY;
      break;
    default:
      assert(("Bad switch", 0));
    }
  }
  return arg;
}
コード例 #9
0
ファイル: loc.c プロジェクト: fhector/helenOS-0.5-Hector
int main(int argc, char *argv[])
{
	int rc;
	char *cmd;
	char *cat_name;
	category_id_t cat_id;

	if (argc <= 1) {
		rc = list_svcs_by_cat();
		if (rc != EOK)
			return 1;
		return 0;
	}

	cmd = argv[1];
	if (str_cmp(cmd, "show-cat") == 0) {
		if (argc < 3) {
			printf("Argument missing.\n");
			print_syntax();
			return 1;
		}

		cat_name = argv[2];
		rc = loc_category_get_id(cat_name, &cat_id, 0);
		if (rc != EOK) {
			printf("Error looking up category '%s'.\n", cat_name);
			return 1;
		}

		rc = show_cat(cat_name, cat_id);
		if (rc != EOK)
			return 1;
	} else {
		printf("Invalid command '%s'\n", cmd);
		print_syntax();
		return 1;
	}

	return 0;
}
コード例 #10
0
ファイル: corecfg.c プロジェクト: jvesely/helenos
int main(int argc, char *argv[])
{
	int rc;

	rc = corecfg_init();
	if (rc != EOK) {
		printf("Failed contacting corecfg service.\n");
		return 1;
	}

	if ((argc < 2) || (str_cmp(argv[1], "get") == 0))
		return corecfg_print();
	else if (str_cmp(argv[1], "enable") == 0)
		return corecfg_set_enable(true);
	else if (str_cmp(argv[1], "disable") == 0)
		return corecfg_set_enable(false);
	else {
		printf("%s: Unknown command '%s'.\n", NAME, argv[1]);
		print_syntax();
		return 1;
	}

	return 0;
}
コード例 #11
0
ファイル: mobiledevice.c プロジェクト: k-yamada/mobiledevice
int main(int argc, char *argv[])
{
  if (argc < 2)
  {
    print_syntax();
    exit(2);
  }

  // get_udid
  if ((argc == 2) && (strcmp(argv[1], "get_udid") == 0))
  {
    command.type = GetUDID;
  }
  // get_bundle_id
  else if ((argc == 3) && (strcmp(argv[1], "get_bundle_id") == 0))
  {
    CFStringRef bundle_id = get_bundle_id(argv[2]);
    if (bundle_id == NULL)
    {
      exit(1);
    }

    char *_bundle_id = create_cstr_from_cfstring(bundle_id);
    CFRelease(bundle_id);

    if (_bundle_id == NULL)
    {
      exit(1);
    }
    printf("%s\n", _bundle_id);
    free(_bundle_id);
    exit(0);
  }
  // install_app
  else if ((argc == 3) && (strcmp(argv[1], "install_app") == 0))
  {
    command.type = InstallApp;
    command.app_path = argv[2];
  }
  // uninstall_app
  else if ((argc == 3) && (strcmp(argv[1], "uninstall_app") == 0))
  {
    command.type = UninstallApp;
    command.bundle_id = argv[2];
  }
  // list_installed_apps
  else if (strcmp(argv[1], "list_installed_apps") == 0)
  {
    command.type = ListInstalledApps;

    if ((argc == 3) && (strcmp(argv[2], "-p") == 0))
    {
      command.print_paths = 1;
    }
    else
    {
      command.print_paths = 0;
    }
  }
  // tunnel
  else if ((argc == 4) && (strcmp(argv[1], "tunnel") == 0))
  {
    command.type = Tunnel;
    command.src_port = (uint16_t)atoi(argv[2]);
    command.dst_port = (uint16_t)atoi(argv[3]);
  }
  else
  {
    fprintf(stderr, "Unknown command\n");
    print_syntax();
    exit(1);
  }

  // wait for device
  register_device_notification();
  return 1;
}
コード例 #12
0
ファイル: collector.c プロジェクト: PieVo/power-meter
int main(int argc, char *argv[])
{
	time_t start, end;
	int i = 1;
	float tmp;
	char string[64];
	struct tm *loctime;
	int day = 0, oldday = 0;

	while (argc > i) {
		if (argv[i][0] == '-') {
			switch(argv[i][1]) {
			case 'd':
				debug = 1;
				dbg("Enable debugging\n");
				break;
			case 'p':
				watt_hour = (int)atoi(argv[i+1]);
				dbg("Preset total used power: %.1fW/h\n", watt_hour);
				i++;
				break;
			case 'r':
				daily_watt_hour = (int)atoi(argv[i+1]);
				dbg("Preset daily used power: %.1fW/h\n", daily_watt_hour);
				i++;
				break;
			default:
				break;
			}
			i++;
		} else {
			print_syntax();
			return -1;
		}
	}

	if (signal(SIGUSR1, sig_handler) == SIG_ERR) {
		printf("Failed to catch SIGUSR1\n");
		return -1;
	}

	if (watt_hour == 0) {
		if (readfloatfromfile(TOTAL, &watt_hour) < 0)
			printf("No total usage data available\n");
		else
			printf("Preset total data from file: %.1fW/h\n", watt_hour);
	}


	one_rotation_wh = 1000 / (float)ROTATIONS_PER_KWH;
	dbg("One rotation is %f Wh, interval is %d minutes\n", one_rotation_wh, INTERVAL);
	start = time(NULL);
	
	/* Prevent inital daily log to be written */
	loctime = localtime(&start);
	oldday = loctime->tm_mday;

	while(1) {
		sleep(1);
		end = time(NULL);
		if (difftime(end, start) >= (INTERVAL * 60)) {
			tmp = interval_power * (60 / INTERVAL);
			dbg("\nCurrent power (%dmin avg): %.1fW (%f)\n", INTERVAL, tmp, interval_power);
			dbg("Total used power: %.1fW/h\n", watt_hour);
			dbg("Daily used power: %.1fW/h\n", daily_watt_hour);

			/* Create a small html file with total value */
			sprintf(string, "<html><h2>Total: %.2fkWh</h2><html>", (watt_hour / 1000));
			writestrtofile(TOTAL_HTML, string, "w");

			/* Store total value in case of reboots etc */
			sprintf(string, "%.1f", watt_hour);
                        writestrtofile(TOTAL, string, "w");

			/* Highcharts requires milliseconds sinds epoc */	
			sprintf(string, "%lu000,%u", time(NULL), (unsigned int)tmp);
			writestrtofile(DETAIL, string, "a");

			interval_power = 0;
			start = time(NULL);

			/* Check for day change and store total */
			loctime = localtime(&start);
			day = loctime->tm_mday;
			if (day != oldday) {
				dbg("Writing (previous day) daily used power to file");
				sprintf(string, "%lu000,%.2f", (start - 3600), (daily_watt_hour / 1000));
				writestrtofile(DAILY, string, "a");
				daily_watt_hour = 0;
			}
			oldday = day;
			
		}
	}
	return 0;
}
コード例 #13
0
ファイル: main_stu.c プロジェクト: tangentforks/qnial
int
main(int argc, char *memin[])
{
    int         i,
                rc;
    int         irc;
    int         messages = true,
#ifdef IBMPCCHARS
                box_chars = true;

#else
                box_chars = false;

#endif
    char        indefsfnm[MAX_FILENM_SIZE],
                inloadfnm[MAX_FILENM_SIZE];


    /* set global variables */

    defssw = false;
    defsfnm = NULL;


    initmemsize = dfmemsize;
    quiet = false;
    expansion = true;
    quiet = false;
    nouserinterrupts = false;
    loadsw = false;
    triggered = true;
    debugging_on = true;
    diag_messages_on = false;
    interpreter_running = false;

#ifdef HISTORY
    lasteval = -1;
#endif

#ifdef DEBUG
    debug = false;
#endif

#ifdef PROFILE
    profile = false;
#endif

    /* Export the command line to the rest of the code */
#ifdef CMDLINE
    global_argv = memin;
    global_argc = argc;
#endif

    /* MAJ: the following code is kept in case I decide to go back
       to having the console and cgi versions the same code.
    */


    if (iscgiversion) {
        quiet = true;
        messages = false;
        box_chars = false;
        triggered = false;
        nouserinterrupts = true;
    }

#ifdef UNIXSYS
    initunixsignals();
#endif


    /* process command arguments

       the allowed syntax is:

       [(+|-)size nnnn] [-defs filenm] [-q] [-m] [-b] [-s] [-d] [workspacename] */


    if (iscgiversion)
        /*  This code will allow the cgi version to accept *.nws, *.ndf or
            *.nfm files on the command line.  No other parameters are available.
        */
    {
        if (argc >= 2)
        {   int offset = (memin[1][0] == '\"') ? -1 : 0;
            if (STRNCASECMP((strlen(memin[1]) +
                             memin[1] - 4 + offset), ".NDF", 4) == 0)
            {   /* arg is a Nial definition file name */
                defssw = true;
                strcpy(indefsfnm, memin[1]);
            }
            else if (STRNCASECMP((strlen(memin[1]) +
                                  memin[1] - 4 + offset), ".NWS", 4) == 0)
            {   /* arg is a Nial workspace file name */
                loadsw = true;
                strcpy(inloadfnm, memin[1]);
            }
        }
    }
    else
    {   i = 1;
        while (i < argc) {
            if (strcmp(memin[i], "-size") == 0) {
                /* set iniital size and allow expansion */
                initmemsize = atol(memin[i + 1]);
                if (initmemsize < minmemsize)
                    initmemsize = minmemsize;
                expansion = true;
                i += 2;
            }
            else if (strcmp(memin[i], "+size") == 0) {
                /* set iniital size and disallow expansion */
                initmemsize = atol(memin[i + 1]);
                if (initmemsize < minmemsize)
                    initmemsize = minmemsize;
                expansion = false;
                i += 2;
            }
            else if (strcmp(memin[i], "-defs") == 0) {
                if (i < argc) {
                    /* explicit defs file name given */
                    defssw = true;
                    strcpy(indefsfnm, memin[i + 1]);
                    i += 2;
                }
                else {
                    printf("missing definition file name after -defs option\n");
                    exit(1);
                }
            }
            else if (strcmp(memin[i], "-q") == 0) {
                /* inhibit all output */
                quiet = true;
                i++;
            }
            else if (strcmp(memin[i], "-m") == 0) {
                /* do not display warning messages */
                messages = false;
                i++;
            }
            else if (strcmp(memin[i], "-d") == 0) {
                /* disable Nial level debugging */
                debugging_on = false;
                i++;
            }
            else
#ifdef IBMPCCHARS
                if (strcmp(memin[i], "-b") == 0) {
                    /* do not use the IMB PC box characters */
                    box_chars = false;
                    i++;
                }
                else
#endif
                    if (strcmp(memin[i], "-s") == 0) {
                        /* suppress fault triggering */
                        triggered = false;
                        i++;
                    }
                    else if (strcmp(memin[i], "-h") == 0) {
                        /* display the help syntax and exit */
                        print_syntax();
                        exit(1);
                    }
                    else if (memin[i][0] == '-') {
                        /* invalid command line. display and exit. */
                        printf("invalid command line option: %s", memin[i]);
                        exit(1);
                    }
                    else {
                        /* assume rest of line is a workspace file name */
                        loadsw = true;
                        strcpy(inloadfnm, memin[i]);
                        i++;
                    }
        }
    }

    /* end of code to process arguments */

    /* code to check if we are running a console version under WINDOWS. If we are
       do not attempt to check for the keyboard, since it slows execution
       outrageously. This has been switched out for now. Not needed since DOS version
       no longer supported.
     */

#ifdef OMITTED
    checkkeyboard = (getenv("WINDIR") == NULL ? true : false);
    /* printf("checkkeyboard %d\n", checkkeyboard); */
#endif


    /* set the session variables */

    sessionSettings = NC_CreateSessionSettings();

    CheckErr(NC_SetSessionSetting(sessionSettings,
                                  NC_WORKSPACE_SIZE, initmemsize));
    CheckErr(NC_SetSessionSetting(sessionSettings,
                                  NC_EXPANSION, expansion));
    if (loadsw)
        CheckErr(NC_SetSessionSetting(sessionSettings,
                                      NC_INITIAL_WORKSPACE, (int) inloadfnm));
    if (defssw)
        CheckErr(NC_SetSessionSetting(sessionSettings,
                                      NC_INITIAL_DEFS, (int) indefsfnm));

    CheckErr(NC_SetSessionSetting(sessionSettings,
                                  NC_QUIET, quiet));
    CheckErr(NC_SetSessionSetting(sessionSettings, NC_DEBUGGING_ON, debugging_on));
    CheckErr(NC_SetCheckUserBreak(sessionSettings, myCheckUserBreak));

    windSettings = NC_CreateWindowSettings();

    if (iscgiversion) /* avoid output by having no prompt in CGINIAL */
        CheckErr(NC_SetWindowSetting(windSettings, NC_PROMPT, (int) ""));

    /* The CGINIAL version is given a default 0 screen width setting,
       so no lines are broken.  */

#ifdef WINDOWS_SYS
    /* The following code is added, so that we can accurately set the
       window's width.  */
    {
        CONSOLE_SCREEN_BUFFER_INFO csbi;

        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
        CheckErr(NC_SetWindowSetting(windSettings, NC_SCREEN_WIDTH,
                                     (iscgiversion ? 0 : ((csbi.srWindow.Right - csbi.srWindow.Left)))));
    }
#else
    CheckErr(NC_SetWindowSetting(windSettings, NC_SCREEN_WIDTH, (iscgiversion ? 0 : 79)));
#endif

    CheckErr(NC_SetWindowSetting(windSettings, NC_TRIGGERED, triggered));
    CheckErr(NC_SetWindowSetting(windSettings, NC_NOUSERINTERRUPTS, nouserinterrupts));

    CheckErr(NC_SetWindowSetting(windSettings, NC_MESSAGES, messages));
    CheckErr(NC_SetWindowSetting(windSettings, NC_BOX_CHARS, box_chars));


#ifdef INTERNAL_BUF_MODE
    theContext = NC_CreateIOContext();
    CheckErr(NC_SetIOMode(theContext, NC_INTERNAL_BUFFER_MODE));
    NC_SetBufferSize(5000, 1000);
#endif


#ifdef IO_MODE
    theContext = NC_CreateIOContext();
    CheckErr(NC_SetIOMode(theContext, NC_IO_MODE));
    CheckErr(NC_SetWriteCommand(theContext, myWrite, stdout));
    CheckErr(NC_SetReadStringCommand(theContext, myReadString, stdin));
    CheckErr(NC_SetReadCharCommand(theContext, myReadChar, stdin));
#endif


    /* get nialroot path from environment on console version */

    {
        char       *nroot;

        nialrootname[0] = '\0';
        nroot = getenv("NIALROOT");
        if (nroot != NULL)
            strcpy(nialrootname, nroot);
    }

    /* initialize the user break capability */
    signal(SIGINT, controlCcatch);


    /* initialize the core routines */
    irc = NC_InitNial(sessionSettings, windSettings, theContext);
    if (NC_IsTerminate(irc))
    {   /* initialization has signalled a termination */
        exit(0);
    }
    else
    {
        CheckErr(irc);
    }



#ifdef INTERNAL_BUF_MODE
    /* display the result in the internal buffer */
    printf("%s", NC_GetBuffer());
#endif

    /* avoid the top level loop in a RUNTIME ONLY or CGINIAL version */

#ifdef RUNTIMEONLY
    goto cleanup;
#endif

#ifdef CGINIAL
    goto cleanup;
#endif


    /* the top level loop */

    do {

retry:
        /* issue the prompt to the console */
        myWrite(stdout, NC_GetPrompt(windSettings));

        userbreakrequested = false; /* could have been set during latent call in
                                 * NC_InitNial() */
        /* get the input string */
        awaitinginput = true;
        myReadInput();
        /* check if the input included a Control C press */
        if (myCheckUserBreak(NC_CS_INPUT)) {
            /* printf("myCheckUserBreak returned true\n"); */ /* remove after testing in UNIX */
            /* make sure workspace is clean */
            cleanup_ws();
#ifdef HISTORY
            if (lasteval != -1) {
                decrrefcnt(lasteval);
                freeup(lasteval);
            }
            lasteval = (-1);
#endif
#ifdef DEBUG
            printf("userbreakrequested set during input at top level loop\n");
#endif
            userbreakrequested = false;
            goto retry;            /* to go around to the prompt again */
        }
        if (EOFsignalled)
        {   /* the feof() code in Borland C returns nonzero if Ctrl-C has been
               pressed. This leads to a premature exit here. Removing the test
               causes nial.exe to loop forever if used as a filter. */
            goto cleanup;
        }

        awaitinginput = false;

        /* interpret the input */
        rc = NC_CommandInterpret(inputline, windSettings, theContext);

        /* check if there was a Control C press during CI execution */
        if (myCheckUserBreak(NC_CS_NORMAL)) {
            cleanup_ws();
#ifdef DEBUG
            printf("userbreakrequested set during input at top level loop\n");
#endif
            userbreakrequested = false;
            goto retry;            /* to go around to the prompt again */
        }

#ifdef INTERNAL_BUF_MODE
        /* display the output if buffered */
        printf("%s\n", NC_GetBuffer());
#endif

        /* check the return code from CI */

        if (!(NC_IsNoError(rc) || NC_IsWarning(rc)
                || NC_IsBreak(rc) || NC_IsTerminate(rc))) {
            /* display error information to console */
            printf("Return Code: %s ErrorTypeName : %s\n", NC_ErrorTypeName(rc),
                   NC_ErrorMessage(rc));
        }

    } while (NC_IsWarning(rc) || NC_IsNoError(rc) || NC_IsBreak(rc));

    /* end of top level loop code */

cleanup:

    /* stop the interpreter and clean up its resource usage */
    NC_StopNial();

    /* clean up the core interface resources */

    CheckErr(NC_DestroyIOContext(theContext));
    CheckErr(NC_DestroyWindowSettings(windSettings));
    CheckErr(NC_DestroySessionSettings(sessionSettings));


    /* return from the console version of Q'Nial */

    /* getchar(); */
    /* MAJ: put in the above getchar here to delay exit so that debug output can be
       seen when running from the Borland interface */
    exit(0);
    return 1;                  /* to satisfy syntax error checking */
}
コード例 #14
0
ファイル: opus_sm_demo.c プロジェクト: jzombi/opus_sm
/* Main program. */
int main(int argc, char* argv[]) {

	const int verbose = 0;

	if ((argc < 2) || (argc > 6)) {
		print_syntax(argv[0]);
		return 1;
	}

	const char* infile  = argv[1];
	const char* out_pmusic = NULL;
	const char* out_labels = NULL;
	double sm_segment_min_dur = 4.0f;
	double b_segment_min_dur = 4.0f;

	if (argc >= 3) {
		out_pmusic = argv[2];
	}

	if (argc >= 4) {
		out_labels = argv[3];
	}

	if (argc >= 5) {
		sm_segment_min_dur = atof(argv[4]);
	}

	if (argc >= 6) {
		b_segment_min_dur = atof(argv[5]);
	}

	/* Load file */
	
	WAVE* wave = open_wav(infile, verbose);
	
	if (wave == NULL) {
		return 1;
	}

	/* Init Opus encoder */

	OpusSM* sm = init_opus(wave);

	if (sm == NULL) {
		wclose(wave);
		return 1;
	}

	/* Open output files */

	FILE* ofp_pmusic = open_output_file(out_pmusic);
	if (ofp_pmusic == NULL) {
		wclose(wave);
		sm_destroy(sm);
		return 1;
	}

	FILE* ofp_labels = open_output_file(out_labels);
	if (ofp_labels == NULL) {
		wclose(wave);
		sm_destroy(sm);
		fclose(ofp_pmusic);
		return 1;
	}

	/* Processing */
	
	int error = process(infile,
	                    wave,
	                    sm,
	                    ofp_pmusic,
	                    ofp_labels,
	                    sm_segment_min_dur,
	                    b_segment_min_dur
	                   );

	/* Clean up */

	sm = sm_destroy(sm);
	wave = wclose(wave);
	fclose(ofp_pmusic);
	fclose(ofp_labels);

	return error;
}
コード例 #15
0
ファイル: interrupts.c プロジェクト: radujipa/RPiSystemTimer
/*
 * A simple program to test the System Timer driver
 ******************************************************************************
 */
int main (int argc, char* argv[])
{
	/*  */	
	unsigned int  read_value ;
	unsigned int write_value = 0 ;

	const char *files[] = {"/dev/CS", "/dev/CLO", "/dev/CHI", "/dev/C0", "/dev/C1", "/dev/C2", "/dev/C3"} ;
	//const unsigned int file_count = sizeof (files) / sizeof (char*) ;

	/*  */
	if (argv[1] == NULL)
	{
		print_syntax () ;
		exit (1) ;
	}

	/*  */
	piHiPri (100) ;

	/*  */
	unsigned int interval ;
	sscanf (argv[1], "%u", &interval) ;

	/* 	 */
	read_from_device (files[1], &read_value) ;
	write_value = (read_value / 10000000 + 1) * 10000000 ;
	write_to_device  (files[4], &write_value) ;



	/*  */
	sigset_t block_mask, oldmask ;
	
	/* Set up the mask of signals to temporarily block. */ 
	sigemptyset (&block_mask) ;
	sigaddset (&block_mask, SIGUSR1) ;
	sigaddset (&block_mask, SIGUSR2) ;

	/*  */
	struct sigaction action ;
  
  /* Establish the signal handler.  */
  action.sa_handler = signal_handler ;
  action.sa_mask = block_mask ;
  action.sa_flags = 0 ;
  
  /*  */
  sigaction (SIGUSR1, &action, NULL) ;
	sigaction (SIGUSR2, &action, NULL) ;

	/*  */
	sigprocmask (SIG_BLOCK, &block_mask, &oldmask) ;
	
	/* Wait for a signal to arrive. */
	while (1)
	  sigsuspend (&oldmask) ;

	/*  */
	sigprocmask (SIG_UNBLOCK, &block_mask, NULL) ;

	
  /* Program exists cleanly */
	return 0 ;
} //main
コード例 #16
0
ファイル: seetex.c プロジェクト: wadejong/NWChem-Json
int main (int argc, char *argv[])
{
  int i;
  char *file_tex;
  char *file_source;
  FILE *texid;
  FILE *srcid;
    

  if (DEBUG_MODE >= 10)
    {
      for (i=0;i<argc;i++)
	(void) printf(" seetex argument: %d  is <%s>\n",i,argv[i]);
      (void) printf("\n");
    }

  if (argc == 1) 
      {
	  (void) printf(" zero arguments: print usage/syntax only \n\n");
	  (void) print_syntax();
	  (void) usage(0);
      }
  for (i=0;i<argc;i++) 
      {
	  if (! strncmp(argv[i],"-h",(size_t) 2)) 
	      {
		  (void) printf(" [-h|-help] flag found: print usage/syntax only\n\n");
		  (void) print_syntax();
		  (void) usage(0);
	      }
      }
  file_tex = argv[(argc-1)];
  if (DEBUG_MODE >= 10) (void) printf(" seetex output file <%s>\n\n",file_tex);
  
  if (is_tex_file(file_tex))  /* is file *.tex ? */
    {
/* check existance and/or permissions */
      if (access(file_tex,F_OK))
	{if (DEBUG_MODE >= 10) (void) printf("Creating %s\n",file_tex);}
      else
	{if (DEBUG_MODE >= 10) (void) printf("Appending to %s\n",file_tex);}
      
      texid = fopen(file_tex,"a");
    }
  else
    (void) seetex_error("tex file not specified in proper order",-1);

  for(i=1;i<(argc-1);i++)
    { 
      file_source = argv[i];
      if (is_fortran_file(file_source) && (!access(file_source,R_OK)))
	{
	  if (DEBUG_MODE >= 10) (void) printf("fortran or seetex include file %s is readable\n",file_source);
	  srcid = fopen(file_source,"r");
	}
      else
	(void) seetex_error
	  (" fortran source or seetex include file does not exist or \n              does not have the proper '.F', '.f', '.fh' suffix",-2);
      if (DEBUG_MODE >= 10)
	{
	  if (is_fortran_file(file_source))
	    (void) printf("%s is a fortran or seetex include file\n",file_source);
	  else
	    (void) printf("%s is NOT a fortran or seetex include file\n",file_source);
	}
      (void) printf(" tex output from <%s> written to <<%s>>\n",file_source,file_tex);
      if (! seetex_process(srcid,texid))
	(void) seetex_error(" error processing fortran source or seetex include file\n",1);
      (void) fflush(texid);
      (void) fclose(srcid);
    }

  (void) fflush(texid);
  (void) fclose(texid);
/* return no error condition */
  return FALSE;
}
コード例 #17
0
ファイル: rescan.c プロジェクト: Duplex923/pzs-ng
int 
main(int argc, char *argv[])
{
	int		n, l, complete_type = 0, not_allowed = 0, argv_mode = 0;

#ifdef USING_GLFTPD
        int             gnum = 0, unum = 0;
	char		myflags[20];
#endif

	char           *ext, exec[4096], *complete_bar = 0, *inc_point[2];
	unsigned int	crc;
	struct stat	fileinfo;

	uid_t		f_uid;
	gid_t		f_gid;
	double		temp_time = 0;

	DIR		*dir, *parent;
	struct dirent	*dp;
	long		loc;
	time_t		timenow;
#if (test_for_password || extract_nfo || zip_clean)
	off_t		tempstream;
#endif

	short		rescan_quick = rescan_default_to_quick;
	char		one_name[NAME_MAX];
	char		*temp_p = NULL;
	int		chdir_allowed = 0, argnum = 0;
	GLOBAL		g;
#if (enable_rescan_script)
	char		target[PATH_MAX+NAME_MAX];
#endif

#if ( program_uid > 0 )
	setegid(program_gid);
	seteuid(program_uid);
#endif

	umask(0666 & 000);

	d_log("rescan: PZS-NG (rescan v2) %s debug log.\n", ng_version);
	d_log("rescan: Rescan executed by: (uid/gid) %d/%d\n", geteuid(), getegid());

#ifdef _ALT_MAX
	d_log("rescan: PATH_MAX not found - using predefined settings! Please report to the devs!\n");
#endif

	d_log("rescan: Allocating memory for variables\n");
	g.ui = ng_realloc2(g.ui, sizeof(*g.ui) * 30, 1, 1, 1);
	g.gi = ng_realloc2(g.gi, sizeof(*g.gi) * 30, 1, 1, 1);

	bzero(one_name, NAME_MAX);

#ifdef USING_GLFTPD
	if (getenv("FLAGS")) {
		strlcpy(myflags, getenv("FLAGS"), sizeof(myflags));
		n = strlen(myflags);
		while (n > 0) {
			--n;
			l = strlen(rescan_chdir_flags);
			while(l > 0) {
				--l;
				if (myflags[n] == rescan_chdir_flags[l])
					chdir_allowed = 1;
			}
		}
	}
	if (!geteuid())
		chdir_allowed = 1;
#endif

	/* With glftpd we can use env vars, rest of the world: commandline. */
#ifndef USING_GLFTPD
	if (argc < 7) {
		print_syntax(chdir_allowed);
		ng_free(g.ui);
		ng_free(g.gi);
		return 0;
	}
	argnum = 6;

	if (chdir(argv[5]) != 0) {
		printf("Could not chdir to <cwd = '%s'>, ftpd agnostic mode: %s\n", argv[5], strerror(errno));
		d_log("rescan: Could not chdir to <cwd = '%s'>, ftpd agnostic mode: %s\n", argv[5], strerror(errno));
		ng_free(g.ui);
		ng_free(g.gi);
		return 1;
        }
#else
	argnum = 1;
#endif

	while ((argnum < argc) && argc > 1) {
		if (!strncasecmp(argv[argnum], "--quick", 7))
			rescan_quick = TRUE;
		else if (!strncasecmp(argv[argnum], "--normal", 8))
			rescan_quick = FALSE;
		else if (!strncasecmp(argv[argnum], "--dir=", 6) && (strlen(argv[argnum]) > 7) && chdir_allowed) {
			temp_p = argv[argnum] + 6;
			if ((!matchpath(nocheck_dirs, temp_p)) && (matchpath(zip_dirs, temp_p) || matchpath(sfv_dirs, temp_p)) && !matchpath(group_dirs, temp_p)) {
				if (chdir(temp_p)) {
					d_log("rescan: Failed to chdir() to %s : %s\n", temp_p, strerror(errno));
					not_allowed = 1;
				}
			} else {
				printf("Not allowed to chdir() to %s\n", temp_p);
				ng_free(g.ui);
				ng_free(g.gi);
				return 1;
			}
			printf("PZS-NG Rescan %s: Rescanning %s\n", ng_version, temp_p);
			argv_mode = 1;

		} else if (!strncasecmp(argv[argnum], "--chroot=", 9) && (strlen(argv[argnum]) > 10) && chdir_allowed) {
			if (temp_p == NULL) {
				temp_p = argv[argnum] + 9;
				if (chroot(temp_p) == -1) {
					d_log("rescan: Failed to chroot() to %s : %s\n", temp_p, strerror(errno));
					not_allowed = 1;
				}
			} else {
				temp_p = argv[argnum] + 9;
				printf("Not allowed to chroot() to %s\n", temp_p);
				ng_free(g.ui);
				ng_free(g.gi);
				return 1;
			}
			printf("PZS-NG Rescan %s: Chroot'ing to %s\n", ng_version, temp_p);
			argv_mode = 1;

		} else if (!strncasecmp(argv[argnum], "--help", 6) || !strncasecmp(argv[argnum], "/?", 2) || !strncasecmp(argv[argnum], "--?", 3)) {
                        print_syntax(chdir_allowed);
			ng_free(g.ui);
			ng_free(g.gi);
                        return 0;
		} else {
			strlcpy(one_name, argv[argnum], sizeof(one_name));
			rescan_quick = FALSE;
			printf("PZS-NG Rescan %s: Rescanning in FILE mode\n", ng_version);
			if (one_name[strlen(one_name) - 1] == '*') {
				one_name[strlen(one_name) - 1] = '\0';
			} else if (!fileexists(one_name)) {
				d_log("PZS-NG Rescan: No file named '%s' exists.\n", one_name);
				one_name[0] = '\0';
				not_allowed = 1;
			}
			argv_mode = 1;
		}
		argnum++;
	}
	if (one_name[0] == '\0') {
		if (rescan_quick == TRUE) {
			printf("PZS-NG Rescan %s: Rescanning in QUICK mode.\n", ng_version);
		} else {
			printf("PZS-NG Rescan %s: Rescanning in NORMAL mode.\n", ng_version);
		}
	}
	printf("PZS-NG Rescan %s: Use --help for options.\n\n", ng_version);

	if (not_allowed) {
		ng_free(g.ui);
		ng_free(g.gi);
		return 1;
	}

	if (!getcwd(g.l.path, PATH_MAX)) {
		d_log("rescan: getcwd() failed: %s\n", strerror(errno));
	}
	if (subcomp(g.l.path, g.l.basepath) && (g.l.basepath[0] == '\0'))
		strlcpy(g.l.basepath, g.l.path, sizeof(g.l.basepath));
	if (strncmp(g.l.path, g.l.basepath, PATH_MAX))
		d_log("rescan: We are in subdir of %s\n", g.l.basepath);
        strlcpy(g.v.misc.current_path, g.l.path, sizeof(g.v.misc.current_path));
        strlcpy(g.v.misc.basepath, g.l.basepath, sizeof(g.v.misc.basepath));

	if ((matchpath(nocheck_dirs, g.l.path) && !rescan_nocheck_dirs_allowed) || (matchpath(group_dirs, g.l.path) && argv_mode) || (!matchpath(nocheck_dirs, g.l.path) && !matchpath(zip_dirs, g.l.path) && !matchpath(sfv_dirs, g.l.path) && !matchpath(group_dirs, g.l.path)) || insampledir(g.l.path)) {
		d_log("rescan: Dir matched with nocheck_dirs/sample_list, or is not in the zip/sfv/group-dirs.\n");
		d_log("rescan: Freeing memory, and exiting.\n");
		printf("Notice: Unable to rescan this dir - check config.\n\n");
		ng_free(g.ui);
		ng_free(g.gi);
		return 0;
	}
	g.v.misc.slowest_user[0] = ULONG_MAX;

	bzero(&g.v.total, sizeof(struct race_total));
	g.v.misc.fastest_user[0] = 0;
	g.v.misc.release_type = RTYPE_NULL;
	g.v.misc.write_log = 0;

#ifdef USING_GLFTPD
	if (getenv("SECTION") == NULL) {
		sprintf(g.v.sectionname, "DEFAULT");
	} else {
		snprintf(g.v.sectionname, sizeof(g.v.sectionname), "%s", getenv("SECTION"));
	}
#else
        snprintf(g.v.sectionname, sizeof(g.v.sectionname), argv[4]);
#endif

	g.l.length_path = (int)strlen(g.l.path);
	g.l.length_zipdatadir = sizeof(storage);
	n = g.l.length_path + g.l.length_zipdatadir + 11;
	g.l.race = ng_realloc2(g.l.race, n, 1, 1, 1);
	g.l.sfv = ng_realloc2(g.l.sfv, n - 1, 1, 1, 1);
	g.l.sfvbackup = ng_realloc2(g.l.sfvbackup, n + 1, 1, 1, 1);
	g.l.leader = ng_realloc2(g.l.leader, n - 2, 1, 1, 1);
	g.l.sfv_incomplete = 0;

	getrelname(&g);

#ifdef USING_GLFTPD
	gnum = buffer_groups(GROUPFILE, 0);
	unum = buffer_users(PASSWDFILE, 0);
#endif

	sprintf(g.l.sfv, storage "/%s/sfvdata", g.l.path);
	sprintf(g.l.sfvbackup, storage "/%s/sfvbackup", g.l.path);
	sprintf(g.l.leader, storage "/%s/leader", g.l.path);
	sprintf(g.l.race, storage "/%s/racedata", g.l.path);
	d_log("rescan: Creating directory to store racedata in\n");
 	maketempdir(g.l.path);

	d_log("rescan: Locking release\n");
	while (1) {
		if ((l = create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 3, 0))) {
			d_log("rescan: Failed to lock release.\n");
			if (l == 1) {
				d_log("rescan: version mismatch. Exiting.\n");
				printf("Error. You need to rm -fR ftp-data/pzs-ng/* before rescan will work.\n"); /* */
				ng_free(g.ui);
				ng_free(g.gi);
				ng_free(g.l.sfv);
				ng_free(g.l.sfvbackup);
				ng_free(g.l.leader);
				ng_free(g.l.race);
#ifdef USING_GLFTPD
				buffer_groups(GROUPFILE, gnum);
				buffer_users(PASSWDFILE, unum);
#endif
				exit(EXIT_FAILURE);
			}
			if (l == PROGTYPE_POSTDEL) {
				n = (signed int)g.v.data_incrementor;
				d_log("rescan: Detected postdel running - sleeping for one second.\n");
				if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
					break;
				usleep(1000000);
				if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
					break;
				if ( n == (signed int)g.v.data_incrementor) {
					d_log("rescan: Failed to get lock. Forcing unlock.\n");
					if (create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 2, g.v.data_queue)) {
						d_log("rescan: Failed to force a lock.\n");
						d_log("rescan: Exiting with error.\n");
						ng_free(g.ui);
						ng_free(g.gi);
						ng_free(g.l.sfv);
						ng_free(g.l.sfvbackup);
						ng_free(g.l.leader);
						ng_free(g.l.race);
#ifdef USING_GLFTPD
						buffer_groups(GROUPFILE, gnum);
						buffer_users(PASSWDFILE, unum);
#endif
						exit(EXIT_FAILURE);
					}
					break;
				}
			} else {
				for (l = 0; l <= max_seconds_wait_for_lock * 10; ++l) {
					d_log("rescan: sleeping for .1 second before trying to get a lock (queue: %d).\n", g.v.data_queue);
					usleep(100000);
					if (!create_lock(&g.v, g.l.path, PROGTYPE_RESCAN, 0, g.v.data_queue))
						break;
				}
				if (l >= max_seconds_wait_for_lock * 10) {
					d_log("rescan: Failed to get lock. Will not force unlock.\n");
					ng_free(g.ui);
					ng_free(g.gi);
					ng_free(g.l.sfv);
					ng_free(g.l.sfvbackup);
					ng_free(g.l.leader);
					ng_free(g.l.race);
#ifdef USING_GLFTPD
					buffer_groups(GROUPFILE, gnum);
					buffer_users(PASSWDFILE, unum);
#endif
					exit(EXIT_FAILURE);
				}
			}
		}
		usleep(10000);
		if (update_lock(&g.v, 1, 0) != -1)
			break;
	}

	move_progress_bar(1, &g.v, g.ui, g.gi);
	if (g.l.incomplete)
		unlink(g.l.incomplete);
	if (del_completebar)
		removecomplete();

	dir = opendir(".");
	parent = opendir("..");

	if (!((rescan_quick && findfileext(dir, ".sfv")) || *one_name)) {
		if (g.l.sfv)
			unlink(g.l.sfv);
		if (g.l.race)
			unlink(g.l.race);
	}
	printf("Rescanning files...\n");

	if (findfileext(dir, ".zip")) {
		if (!fileexists(unzip_bin)) {
			printf("rescan: ERROR! Not able to check zip-files - %s does not exist!\n", unzip_bin);
			closedir(dir);
			closedir(parent);
			ng_free(g.ui);
			ng_free(g.gi);
			ng_free(g.l.sfv);
			ng_free(g.l.sfvbackup);
			ng_free(g.l.leader);
			ng_free(g.l.race);
#ifdef USING_GLFTPD
			buffer_groups(GROUPFILE, gnum);
			buffer_users(PASSWDFILE, unum);
#endif
			remove_lock(&g.v);
			exit(EXIT_FAILURE);
		} else {
			crc = 0;
			rewinddir(dir);
			timenow = time(NULL);
			while ((dp = readdir(dir))) {
				ext = find_last_of(dp->d_name, ".");
				if (*ext == '.')
					ext++;
				if (!strcasecmp(ext, "zip")) {
					stat(dp->d_name, &fileinfo);
					f_uid = fileinfo.st_uid;
					f_gid = fileinfo.st_gid;
					if ((timenow == fileinfo.st_ctime) && (fileinfo.st_mode & 0111)) {
						d_log("rescan.c: Seems this file (%s) is in the process of being uploaded. Ignoring for now.\n", dp->d_name);
						continue;
					}
#ifdef USING_GLFTPD
					strlcpy(g.v.user.name, get_u_name(f_uid), sizeof(g.v.user.name));
					strlcpy(g.v.user.group, get_g_name(f_gid), sizeof(g.v.user.group));
#else
					strlcpy(g.v.user.name, argv[1], sizeof(g.v.user.name));
					strlcpy(g.v.user.group, argv[2], sizeof(g.v.user.group));
#endif
					strlcpy(g.v.file.name, dp->d_name, sizeof(g.v.file.name));
					g.v.file.speed = 2005 * 1024;
					g.v.file.size = fileinfo.st_size;
					g.v.total.start_time = 0;
#if (test_for_password || extract_nfo)
					tempstream = telldir(dir);
					if ((!findfileextcount(dir, ".nfo") || findfileextcount(dir, ".zip")) && !mkdir(".unzipped", 0777))
						snprintf(exec, sizeof(exec), "%s -qqjo \"%s\" -d .unzipped 2>.delme", unzip_bin, g.v.file.name);
					else
						snprintf(exec, sizeof(exec), "%s -qqt \"%s\" 2>.delme", unzip_bin, g.v.file.name);
					seekdir(dir, tempstream);
#else
					snprintf(exec, sizeof(exec), "%s -qqt \"%s\" 2>.delme", unzip_bin, g.v.file.name);
#endif
					if (system(exec) == 0 || (allow_error2_in_unzip == TRUE && errno < 3 )) {
						writerace(g.l.race, &g.v, crc, F_CHECKED);
					} else {
						writerace(g.l.race, &g.v, crc, F_BAD);
						if (g.v.file.name)
							unlink(g.v.file.name);
						removedir(".unzipped");
						continue;
					}
#if (test_for_password || extract_nfo || zip_clean)
					tempstream = telldir(dir);
                        	        if ((!findfileextcount(dir, ".nfo") || findfileextcount(dir, ".zip")) && check_zipfile(".unzipped", g.v.file.name, findfileextcount(dir, ".nfo"))) {
                                	        d_log("rescan: File %s is password protected.\n", g.v.file.name);
						writerace(g.l.race, &g.v, crc, F_BAD);
						if (g.v.file.name)
							unlink(g.v.file.name);
						seekdir(dir, tempstream);
						continue;
	                                }
					seekdir(dir, tempstream);
#endif
					if (!fileexists("file_id.diz")) {
						snprintf(exec, sizeof(exec), "%s -qqjnCLL \"%s\" file_id.diz 2>.delme", unzip_bin, g.v.file.name);
						if (execute(exec) != 0) {
							d_log("rescan: No file_id.diz found (#%d): %s\n", errno, strerror(errno));
						} else {
							if (fileexists("file_id.diz.bad")) {
								loc = findfile(dir, "file_id.diz.bad");
								seekdir(dir, loc);
								dp = readdir(dir);
								unlink(dp->d_name);
							}
							if (chmod("file_id.diz", 0666))
								d_log("rescan: Failed to chmod %s: %s\n", "file_id.diz", strerror(errno));
						}
					}
				}
			}

			if (fileexists(".delme"))
				unlink(".delme");

			g.v.total.files = read_diz();
			if (!g.v.total.files) {
				g.v.total.files = 1;
				unlink("file_id.diz");
			}
			g.v.total.files_missing = g.v.total.files;
			readrace(g.l.race, &g.v, g.ui, g.gi);
			sortstats(&g.v, g.ui, g.gi);
			if (g.v.total.files_missing < 0) {
				g.v.total.files -= g.v.total.files_missing;
				g.v.total.files_missing = 0;
			}
			buffer_progress_bar(&g.v);
			if (g.v.total.files_missing == 0) {
				complete(&g, complete_type);
				createstatusbar(convert(&g.v, g.ui, g.gi, zip_completebar));
#if (chmod_completebar)
				if (!matchpath(group_dirs, g.l.path)) {
					if (chmod_each(convert(&g.v, g.ui, g.gi, zip_completebar), 0222))
						d_log("rescan: Failed to chmod a statusbar: %s\n", strerror(errno));
				}
#endif

			} else {
				if (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) {
					if (create_incomplete()) {
						d_log("rescan: create_incomplete() returned something\n");
					}
				}
				move_progress_bar(0, &g.v, g.ui, g.gi);
			}
			if (g.l.nfo_incomplete) {
				if (findfileext(dir, ".nfo")) {
					d_log("rescan: Removing missing-nfo indicator (if any)\n");
					remove_nfo_indicator(&g);
				} else if (matchpath(check_for_missing_nfo_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
					if (!g.l.in_cd_dir) {
						d_log("rescan: Creating missing-nfo indicator %s.\n", g.l.nfo_incomplete);
						if (create_incomplete_nfo()) {
							d_log("rescan: create_incomplete_nfo() returned something\n");
						}
					} else {
						if (findfileextparent(parent, ".nfo")) {
							d_log("rescan: Removing missing-nfo indicator (if any)\n");
							remove_nfo_indicator(&g);
						} else {
							d_log("rescan: Creating missing-nfo indicator (base) %s.\n", g.l.nfo_incomplete);
							if (create_incomplete_nfo()) {
								d_log("rescan: create_incomplete_nfo() returned something\n");
							}
						}
					}
				}
			}
		}
	} else if ((temp_p = findfileext(dir, ".sfv")) || (create_missing_sfv && file_count(dir))) {
		if (!temp_p && create_missing_sfv && file_count(dir)) {
			d_log("rescan: No sfv found - creating one.\n");
			make_sfv(g.l.path);
			if (!(temp_p = findfileext(dir, ".sfv"))) {
				d_log("rescan: Freeing memory, removing lock and exiting.\n");
				unlink(g.l.sfv);
				if (fileexists(g.l.sfvbackup))
				unlink(g.l.sfvbackup);
				unlink(g.l.race);
				closedir(dir);
				closedir(parent);
				ng_free(g.ui);
				ng_free(g.gi);
				ng_free(g.l.sfv);
				ng_free(g.l.sfvbackup);
				ng_free(g.l.leader);
				ng_free(g.l.race);
#ifdef USING_GLFTPD
				buffer_groups(GROUPFILE, gnum);
				buffer_users(PASSWDFILE, unum);
#endif
				remove_lock(&g.v);
				return 0;
			}
		}
#if ( create_missing_sfv_link == TRUE )
		d_log("rescan: Removing missing-sfv indicator (if any)\n");
		unlink(g.l.sfv_incomplete);
#endif
		strlcpy(g.v.file.name, temp_p, sizeof(g.v.file.name));

		maketempdir(g.l.path);
		stat(g.v.file.name, &fileinfo);

		if (copysfv(g.v.file.name, g.l.sfv, &g.v)) {
			printf("Found invalid entries in SFV - Exiting.\n");

			while ((dp = readdir(dir))) {
				ext = find_last_of(dp->d_name, "-");
				if (!strcasecmp(ext, "-missing"))
					unlink(dp->d_name);
			}

			d_log("rescan: Freeing memory, removing lock and exiting\n");
			unlink(g.l.sfv);
			if (fileexists(g.l.sfvbackup))
			unlink(g.l.sfvbackup);
			unlink(g.l.race);
			closedir(dir);
			closedir(parent);
			ng_free(g.ui);
			ng_free(g.gi);
			ng_free(g.l.sfv);
			ng_free(g.l.sfvbackup);
			ng_free(g.l.leader);
			ng_free(g.l.race);
#ifdef USING_GLFTPD
			buffer_groups(GROUPFILE, gnum);
			buffer_users(PASSWDFILE, unum);
#endif
			remove_lock(&g.v);

			return 0;
		}
		g.v.total.start_time = 0;
		rewinddir(dir);
		while ((dp = readdir(dir))) {
			if (*one_name && strncasecmp(one_name, dp->d_name, strlen(one_name)))
				continue;

			l = (int)strlen(dp->d_name);

			ext = find_last_of(dp->d_name, ".-");
			if (*ext == '.')
				ext++;

			if (!update_lock(&g.v, 1, 0)) {
				d_log("rescan: Another process wants the lock - will comply and remove lock, then exit.\n");
				closedir(dir);
				closedir(parent);
				ng_free(g.ui);
				ng_free(g.gi);
				ng_free(g.l.sfv);
				ng_free(g.l.sfvbackup);
				ng_free(g.l.leader);
				ng_free(g.l.race);
#ifdef USING_GLFTPD
				buffer_groups(GROUPFILE, gnum);
				buffer_users(PASSWDFILE, unum);
#endif
				remove_lock(&g.v);
				exit(EXIT_FAILURE);
			}

			if (
				!strcomp(ignored_types, ext) &&
				(!(strcomp(allowed_types, ext) && !matchpath(allowed_types_exemption_dirs, g.l.path))) &&
				strcasecmp("sfv", ext) &&
				strcasecmp("nfo", ext) &&
				strcasecmp("bad", ext) &&
				strcasecmp("-missing", ext) &&
				strncmp(dp->d_name, ".", 1)
				) {

				stat(dp->d_name, &fileinfo);

				if (S_ISDIR(fileinfo.st_mode))
					continue;
				if (ignore_zero_sized_on_rescan && !fileinfo.st_size)
					continue;

				f_uid = fileinfo.st_uid;
				f_gid = fileinfo.st_gid;

#ifdef USING_GLFTPD
				strlcpy(g.v.user.name, get_u_name(f_uid), sizeof(g.v.user.name));
				strlcpy(g.v.user.group, get_g_name(f_gid), sizeof(g.v.user.group));
#else
				strlcpy(g.v.user.name, argv[1], sizeof(g.v.user.name));
				strlcpy(g.v.user.group, argv[2], sizeof(g.v.user.group));
#endif

				strlcpy(g.v.file.name, dp->d_name, sizeof(g.v.file.name));
				g.v.file.speed = 2005 * 1024;
				g.v.file.size = fileinfo.st_size;

				temp_time = fileinfo.st_mtime;

				if (g.v.total.start_time == 0)
					g.v.total.start_time = temp_time;
				else
					g.v.total.start_time = (g.v.total.start_time < temp_time ? g.v.total.start_time : temp_time);

				g.v.total.stop_time = (temp_time > g.v.total.stop_time ? temp_time : g.v.total.stop_time);

				/* Hide users in group_dirs */
				if (matchpath(group_dirs, g.l.path) && (hide_group_uploaders == TRUE)) {
					d_log("rescan: Hiding user in group-dir:\n");
					if ((int)strlen(hide_gname) > 0) {
						snprintf(g.v.user.group, sizeof(g.v.user.group), "%s", hide_gname);
						d_log("rescan:    Changing groupname\n");
					}
					if ((int)strlen(hide_uname) > 0) {
						snprintf(g.v.user.name, sizeof(g.v.user.name), "%s", hide_uname);
						d_log("rescan:    Changing username\n");
					}
#if (show_users_in_group_dirs == FALSE)
					if ((int)strlen(hide_uname) == 0) {
						d_log("rescan:    Making username = groupname\n");
						snprintf(g.v.user.name, sizeof(g.v.user.name), "%s", g.v.user.group);
					}
#endif
				}

				if (!rescan_quick || (g.l.race && !match_file(g.l.race, dp->d_name)))
					crc = calc_crc32(dp->d_name);
				else
 					crc = 1;

				if (!S_ISDIR(fileinfo.st_mode)) {
					if (g.v.file.name)
						unlink_missing(g.v.file.name);
					if (l > 44) {
						if (crc == 1)
							printf("\nFile: %s CHECKED", dp->d_name + l - 44);
						else
							printf("\nFile: %s %.8x", dp->d_name + l - 44, crc);
					} else {
						if (crc == 1)
							printf("\nFile: %-44s CHECKED", dp->d_name);
						else
							printf("\nFile: %-44s %.8x", dp->d_name, crc);
					}
				}
				if(fflush(stdout))
					d_log("rescan: ERROR: %s\n", strerror(errno));
				if (!rescan_quick || (g.l.race && !match_file(g.l.race,	dp->d_name)) || !fileexists(dp->d_name))
					writerace(g.l.race, &g.v, crc, F_NOTCHECKED);
			}
		}
		printf("\n");
		testfiles(&g.l, &g.v, 1);
		printf("\n");
		readsfv(g.l.sfv, &g.v, 0);
		readrace(g.l.race, &g.v, g.ui, g.gi);
		sortstats(&g.v, g.ui, g.gi);
		buffer_progress_bar(&g.v);

		if (g.l.nfo_incomplete) {
			if (findfileext(dir, ".nfo")) {
				d_log("rescan: Removing missing-nfo indicator (if any)\n");
				remove_nfo_indicator(&g);
			} else if (matchpath(check_for_missing_nfo_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
				if (!g.l.in_cd_dir) {
					d_log("rescan: Creating missing-nfo indicator %s.\n", g.l.nfo_incomplete);
					if (create_incomplete_nfo()) {
						d_log("rescan: create_incomplete_nfo() returned something\n");
					}
				} else {
					if (findfileextparent(parent, ".nfo")) {
						d_log("rescan: Removing missing-nfo indicator (if any)\n");
						remove_nfo_indicator(&g);
					} else {
						d_log("rescan: Creating missing-nfo indicator (base) %s.\n", g.l.nfo_incomplete);

						/* This is not pretty, but should be functional. */
						if ((inc_point[0] = find_last_of(g.l.path, "/")) != g.l.path)
							*inc_point[0] = '\0';
						if ((inc_point[1] = find_last_of(g.v.misc.release_name, "/")) != g.v.misc.release_name)
							*inc_point[1] = '\0';
						if (create_incomplete_nfo()) {
							d_log("rescan: create_incomplete_nfo() returned something\n");
						}
						if (*inc_point[0] == '\0')
							*inc_point[0] = '/';
						if (*inc_point[1] == '\0')
							*inc_point[1] = '/';
					}
				}
			}
		}
#if (create_missing_sample_link)
		if (g.l.sample_incomplete) {
			if (findfileextsub(dir) || matchpartialdirname(missing_sample_check_ignore_list, g.v.misc.release_name, missing_sample_check_ignore_dividers)) {
				d_log("rescan: Removing missing-sample indicator (if any)\n");
				remove_sample_indicator(&g);
			} else if (matchpath(check_for_missing_sample_dirs, g.l.path) && (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs)) {
				if (!g.l.in_cd_dir) {
					d_log("rescan: Creating missing-sample indicator %s.\n", g.l.sample_incomplete);
					if (create_incomplete_sample()) {
						d_log("rescan: create_incomplete_sample() returned something\n");
					}
				} else {
					if (findfileextsubp(dir)) {
						d_log("rescan: Removing missing-sample indicator (if any)\n");
						remove_sample_indicator(&g);
					} else {
						d_log("rescan: Creating missing-sample indicator (base) %s.\n", g.l.sample_incomplete);

						/* This is not pretty, but should be functional. */
						if ((inc_point[0] = find_last_of(g.l.path, "/")) != g.l.path)
							*inc_point[0] = '\0';
						if ((inc_point[1] = find_last_of(g.v.misc.release_name, "/")) != g.v.misc.release_name)
							*inc_point[1] = '\0';
						if (create_incomplete_sample()) {
							d_log("rescan: create_incomplete_sample() returned something\n");
						}
						if (*inc_point[0] == '\0')
							*inc_point[0] = '/';
						if (*inc_point[1] == '\0')
							*inc_point[1] = '/';
					}
				}
			}
		}
#endif
		if (g.v.misc.release_type == RTYPE_AUDIO) {
			get_audio_info(findfileextfromlist(dir, audio_types), &g.v.audio);
			/* Sort if we're not in a group-dir/nosort-dir. */
			if (!matchpath(group_dirs, g.l.path) && !matchpath(audio_nosort_dirs, g.l.path)) {
				printf(" Resorting release.\n");
				audioSort(&g.v.audio, g.l.link_source, g.l.link_target);
			}
		}
		if ((g.v.total.files_missing == 0) && (g.v.total.files > 0)) {

			switch (g.v.misc.release_type) {
			case RTYPE_RAR:
				complete_bar = rar_completebar;
				break;
			case RTYPE_OTHER:
				complete_bar = other_completebar;
				break;
			case RTYPE_AUDIO:
				complete_bar = audio_completebar;
#if ( create_m3u == TRUE )
				n = snprintf(exec, sizeof(exec), "%s", findfileext(dir, ".sfv"));
				strcpy(exec + n - 3, "m3u");
				create_indexfile(g.l.race, &g.v, exec);
#endif
				break;
			case RTYPE_VIDEO:
				complete_bar = video_completebar;
				break;
			}
			complete(&g, complete_type);

			if (complete_bar) {
				createstatusbar(convert(&g.v, g.ui, g.gi, complete_bar));
#if (chmod_completebar)
				if (!matchpath(group_dirs, g.l.path)) {
                                        if (chmod_each(convert(&g.v, g.ui, g.gi, complete_bar), 0222))
                                                d_log("rescan: Failed to chmod a statusbar: %s\n", strerror(errno));
				}
#endif
			}
#if (enable_rescan_script)
			d_log("rescan: Executing rescan_script script\n");
			if (!fileexists(rescan_script)) {
				d_log("rescan: Warning - rescan_script (%s) - file does not exist!\n", rescan_script);
			} else {
				snprintf(target, sizeof(target), rescan_script " \"%s\"", g.v.file.name);
				if (execute(target) != 0)
					d_log("rescan: Failed to execute rescan_script: %s\n", strerror(errno));
			}
#endif
		} else {
			if (!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) {
				if (create_incomplete()) {
					d_log("rescan: create_incomplete() returned something\n");
				}
			}
				move_progress_bar(0, &g.v, g.ui, g.gi);
		}
	} else {
		int empty = 1;
#if (create_missing_sfv_link == TRUE)
		if ((!matchpath(group_dirs, g.l.path) || create_incomplete_links_in_group_dirs) && g.l.sfv_incomplete && !matchpath(nocheck_dirs, g.l.path) && !matchpath(allowed_types_exemption_dirs, g.l.path)) {
			rewinddir(dir);
			while ((dp = readdir(dir))) {
				stat(dp->d_name, &fileinfo);
				if (S_ISREG(fileinfo.st_mode)) {
					ext = find_last_of(dp->d_name, ".");
					if (*ext == '.')
						ext++;
					if (*ext && get_filetype(&g, ext) == 3) {
						d_log("rescan: Creating missing-sfv indicator %s.\n", g.l.sfv_incomplete);
						if (create_incomplete_sfv())
							d_log("rescan: create_incomplete_sfv() returned something.\n");
						empty = 0;
						break;
					}
				}
			}
		}
#endif
		if (empty && mark_empty_dirs_as_incomplete_on_rescan) {
			if (create_incomplete()) {
				d_log("rescan: create_incomplete() returned something\n");
			}
			printf(" Empty dir - marking as incomplete.\n");
		}
	}

	printf(" Passed : %i\n", (int)g.v.total.files - (int)g.v.total.files_missing);
	printf(" Failed : %i\n", (int)g.v.total.files_bad);
	printf(" Missing: %i\n", (int)g.v.total.files_missing);
	printf("  Total : %i\n", (int)g.v.total.files);

	if (g.v.total.files && !g.v.total.files_missing) {
		g.v.misc.data_completed = 1;
	} else {
		g.v.misc.data_completed = 0;
	}

	d_log("rescan: Freeing memory and removing lock.\n");
	closedir(dir);
	closedir(parent);
	ng_free(g.l.race);
	ng_free(g.l.sfv);
	ng_free(g.l.sfvbackup);
	ng_free(g.l.leader);

	remove_lock(&g.v);
	updatestats_free(&g);

#ifdef USING_GLFTPD
	buffer_groups(GROUPFILE, gnum);
	buffer_users(PASSWDFILE, unum);
#endif

	exit(0);
}
コード例 #18
0
void import_m3u_playlist(netmd_dev_handle* devh, const char *file)
{
    FILE *fp;
    char buffer[M3U_LINE_MAX + 1];
    char *s;
    uint8_t track;
    int discard;

    if( file == NULL )
    {
        printf( "No filename specified\n" );
        print_syntax();
        return;
    }

    if( (fp = fopen( file, "r" )) == NULL )
    {
        printf( "Unable to open file %s: %s\n", file, strerror( errno ));
        return;
    }

    if( ! fgets( buffer, M3U_LINE_MAX, fp )) {
        printf( "File Read error\n" );
        return;
    }
    if( strcmp( buffer, "#EXTM3U\n" )) {
        printf( "Invalid M3U playlist\n" );
        return;
    }

    track = 0;
    discard = 0;
    while( fgets( buffer, M3U_LINE_MAX, fp) != NULL ) {
        /* Chomp newlines */
        s = strchr( buffer, '\n' );
        if( s )
            *s = '\0';

        if( buffer[0] == '#' )
        {
            /* comment, ext3inf etc... we only care about ext3inf */
            if( strncmp( buffer, "#EXTINF:", 8 ))
            {
                printf( "Skip: %s\n", buffer );
            }
            else
            {
                s = strchr( buffer, ',' );
                if( !s )
                {
                    printf( "M3U Syntax error! %s\n", buffer );
                }
                else
                {
                    s++;
                    printf( "Title track %d - %s\n", track, s );
                    netmd_set_title(devh, track, s); /* XXX Handle errors */
                    discard = 1;	/* don't fallback to titling by filename */
                }
            }
        }
        else
        {
            /* Filename line */
            if( discard )
            {
                /* printf( "Discard: %s\n", buffer ); */
                discard = 0;
            }
            else
            {
                /* Try and generate a title from the track name */
                s = strrchr( buffer, '.' ); /* Isolate extension */
                if( s )
                    *s = 0;
                s = strrchr( buffer, '/' ); /* Isolate basename */
                if( !s )
                    s = strrchr( buffer, '\\' ); /* Handle DOS paths? */
                if( !s )
                    s = buffer;
                else
                    s++;

                printf( "Title track %d - %s\n", track, s );
                netmd_set_title(devh, track, s); /* XXX Handle errors */
            }
            track++;
        }
    }
}
コード例 #19
0
int main(int argc, char* argv[])
{
    netmd_dev_handle* devh;
    minidisc my_minidisc, *md = &my_minidisc;
    netmd_device *device_list, *netmd;
    unsigned int i = 0;
    unsigned int j = 0;
    char name[16];
    uint16_t track, playmode;
    int c;
    netmd_time time;
    netmd_error error;
    FILE *f;

    error = netmd_init(&device_list);
    if (error != NETMD_NO_ERROR) {
        printf("Error initializing netmd\n%s\n", netmd_strerror(error));
        return -1;
    }

    if (device_list == NULL) {
        puts("Found no NetMD device(s).");
        return -1;
    }

    /* pick first available device */
    netmd = device_list;

    error = netmd_open(netmd, &devh);
    if(error != NETMD_NO_ERROR)
    {
        printf("Error opening netmd\n%s\n", netmd_strerror(error));
        return -1;
    }

    error = netmd_get_devname(devh, name, 16);
    if (error != NETMD_NO_ERROR)
    {
        printf("Could not get device name\n%s\n", netmd_strerror(error));
        return -1;
    }
    printf("%s\n", name);

    netmd_initialize_disc_info(devh, md);
    printf("Disc Title: %s\n\n", md->groups[0].name);

    /* by default, log only errors */
    netmd_set_log_level(NETMD_LOG_ERROR);

    /* parse options */
    while (1) {
        c = getopt(argc, argv, "t");
        if (c == -1) {
            break;
        }
        switch (c) {
        case 't':
            netmd_set_log_level(NETMD_LOG_ALL);
            break;
        default:
            fprintf(stderr, "Unknown option '%c'\n", c);
            break;
        }
    }

    /* update argv and argc after parsing options */
    argv = &argv[optind - 1];
    argc -= (optind - 1);

    /* parse commands */
    if(argc > 1)
    {
        if(strcmp("rename", argv[1]) == 0)
        {
            i = strtoul(argv[2], NULL, 10);
            netmd_cache_toc(devh);
            netmd_set_title(devh, i & 0xffff, argv[3]);
            netmd_sync_toc(devh);
        }
        else if(strcmp("move", argv[1]) == 0)
        {
            i = strtoul(argv[2], NULL, 10);
            j = strtoul(argv[3], NULL, 10);
            netmd_move_track(devh, i & 0xffff, j & 0xffff);
        }
        else if(strcmp("groupmove", argv[1]) == 0)
        {
            i = strtoul(argv[2], NULL, 10);
            j = strtoul(argv[3], NULL, 10);
            netmd_move_group(devh, md, j & 0xffff, i & 0xffff);
        }
        else if(strcmp("write", argv[1]) == 0)
        {
            if(netmd_write_track(devh, argv[2]) < 0)
            {
                fprintf(stderr, "Error writing track %i\n", errno);
            }
        }
        else if(strcmp("newgroup", argv[1]) == 0)
        {
            netmd_create_group(devh, md, argv[2]);
        }
        else if(strcmp("settitle", argv[1]) == 0)
        {
            netmd_cache_toc(devh);
            netmd_set_disc_title(devh, argv[2], strlen(argv[2]));
            netmd_sync_toc(devh);
        }
        else if(strcmp("group", argv[1]) == 0)
        {
            i = strtoul(argv[2], NULL, 10);
            j = strtoul(argv[3], NULL, 10);
            if(!netmd_put_track_in_group(devh, md, i & 0xffff, j & 0xffff))
            {
                printf("Something screwy happened\n");
            }
        }
        else if(strcmp("retitle", argv[1]) == 0)
        {
            i = strtoul(argv[2], NULL, 10);
            netmd_set_group_title(devh, md, i, argv[3]);
        }
        else if(strcmp("play", argv[1]) == 0)
        {
            if( argc > 2 ) {
                i = strtoul(argv[2],NULL, 10);
                netmd_set_track( devh, i & 0xffff );
            }
            netmd_play(devh);
        }
        else if(strcmp("stop", argv[1]) == 0)
        {
            netmd_stop(devh);
        }
        else if(strcmp("pause", argv[1]) == 0)
        {
            netmd_pause(devh);
        }
        else if(strcmp("fforward", argv[1]) == 0)
        {
            netmd_fast_forward(devh);
        }
        else if(strcmp("rewind", argv[1]) == 0)
        {
            netmd_rewind(devh);
        }
        else if(strcmp("next", argv[1]) == 0)
        {
            netmd_track_next(devh);
        }
        else if(strcmp("previous", argv[1]) == 0)
        {
            netmd_track_previous(devh);
        }
        else if(strcmp("restart", argv[1]) == 0)
        {
            netmd_track_restart(devh);
        }
        else if(strcmp("settime", argv[1]) == 0)
        {
            track = strtoul(argv[2], (char **) NULL, 10) & 0xffff;
            if (argc > 6)
            {
                time.hour = strtoul(argv[3], (char **) NULL, 10) & 0xffff;
                time.minute = strtoul(argv[4], (char **) NULL, 10) & 0xff;
                time.second = strtoul(argv[5], (char **) NULL, 10) & 0xff;
                time.frame = strtoul(argv[6], (char **) NULL, 10) & 0xff;
            }
            else
            {
                time.hour = 0;
                time.minute = strtoul(argv[3], (char **) NULL, 10) & 0xff;
                time.second = strtoul(argv[4], (char **) NULL, 10) & 0xff;
                if (argc > 5)
                {
                    time.frame = strtoul(argv[5], (char **) NULL, 10) & 0xff;;
                }
                else
                {
                    time.frame = 0;
                }
            }

            netmd_set_time(devh, track, &time);
        }
        else if(strcmp("m3uimport", argv[1]) == 0)
        {
            import_m3u_playlist(devh, argv[2]);
        }
        else if(strcmp("delete", argv[1]) == 0)
        {
            i = strtoul(argv[2], NULL, 10);
            netmd_delete_track(devh, i & 0xffff);
        }
        else if(strcmp("deletegroup", argv[1]) == 0)
        {
            i = strtoul(argv[2], NULL, 10);
            netmd_delete_group(devh, md, i & 0xffff);
        }
        else if(strcmp("status", argv[1]) == 0) {
            print_current_track_info(devh);
        }
        else if (strcmp("raw", argv[1]) == 0) {
            send_raw_message(devh, argv[2]);
        }
        else if (strcmp("setplaymode", argv[1]) == 0) {
            playmode = 0;
            int i;
            for (i = 2; i < argc; i++) {
                if (strcmp(argv[i], "single") == 0) {
                    playmode |= NETMD_PLAYMODE_SINGLE;
                }
                else if (strcmp(argv[i], "repeat") == 0) {
                    playmode |= NETMD_PLAYMODE_REPEAT;
                }
                else if (strcmp(argv[i], "shuffle") == 0) {
                    playmode |= NETMD_PLAYMODE_SHUFFLE;
                }
            }
            printf("%x\n", playmode);
            netmd_set_playmode(devh, playmode);
        }
        else if (strcmp("capacity", argv[1]) == 0) {
            netmd_disc_capacity capacity;
            netmd_get_disc_capacity(devh, &capacity);

            printf("Recorded:  ");
            print_time(&capacity.recorded);
            printf("\nTotal:     ");
            print_time(&capacity.total);
            printf("\nAvailable: ");
            print_time(&capacity.available);
            printf("\n");
        }
        else if (strcmp("recv", argv[1]) == 0) {
            i = strtoul(argv[2], NULL, 10);
            f = fopen(argv[3], "wb");
            netmd_secure_recv_track(devh, i & 0xffff, f);
            fclose(f);
        }
        else if (strcmp("send", argv[1]) == 0) {
            netmd_error error;
            netmd_ekb ekb;
            unsigned char chain[] = {0x25, 0x45, 0x06, 0x4d, 0xea, 0xca,
                                     0x14, 0xf9, 0x96, 0xbd, 0xc8, 0xa4,
                                     0x06, 0xc2, 0x2b, 0x81, 0x49, 0xba,
                                     0xf0, 0xdf, 0x26, 0x9d, 0xb7, 0x1d,
                                     0x49, 0xba, 0xf0, 0xdf, 0x26, 0x9d,
                                     0xb7, 0x1d};
            unsigned char signature[] = {0xe8, 0xef, 0x73, 0x45, 0x8d, 0x5b,
                                         0x8b, 0xf8, 0xe8, 0xef, 0x73, 0x45,
                                         0x8d, 0x5b, 0x8b, 0xf8, 0x38, 0x5b,
                                         0x49, 0x36, 0x7b, 0x42, 0x0c, 0x58};
            unsigned char rootkey[] = {0x13, 0x37, 0x13, 0x37, 0x13, 0x37,
                                       0x13, 0x37, 0x13, 0x37, 0x13, 0x37,
                                       0x13, 0x37, 0x13, 0x37};
            netmd_keychain *keychain;
            netmd_keychain *next;
            size_t done;
            unsigned char hostnonce[8] = { 0 };
            unsigned char devnonce[8] = { 0 };
            unsigned char sessionkey[8] = { 0 };
            unsigned char kek[] = { 0x14, 0xe3, 0x83, 0x4e, 0xe2, 0xd3, 0xcc, 0xa5 };
            unsigned char contentid[] = { 0x01, 0x0F, 0x50, 0x00, 0x00, 0x04,
                                          0x00, 0x00, 0x00, 0x48, 0xA2, 0x8D,
                                          0x3E, 0x1A, 0x3B, 0x0C, 0x44, 0xAF,
                                          0x2f, 0xa0 };
            netmd_track_packets *packets = NULL;
            size_t packet_count = 0;
            struct stat stat_buf;
            unsigned char *data;
            size_t data_size;

            uint16_t track;
            unsigned char uuid[8] = { 0 };
            unsigned char new_contentid[20] = { 0 };

            error = netmd_secure_leave_session(devh);
            puts(netmd_strerror(error));

            error = netmd_secure_set_track_protection(devh, 0x01);
            puts(netmd_strerror(error));

            error = netmd_secure_enter_session(devh);
            puts(netmd_strerror(error));

            /* build ekb */
            ekb.id = 0x26422642;
            ekb.depth = 9;
            ekb.signature = malloc(sizeof(signature));
            memcpy(ekb.signature, signature, sizeof(signature));

            /* build ekb key chain */
            ekb.chain = NULL;
            for (done = 0; done < sizeof(chain); done+=16U)
            {
                next = malloc(sizeof(netmd_keychain));
                if (ekb.chain == NULL) {
                    ekb.chain = next;
                }
                else {
                    keychain->next = next;
                }
                next->next = NULL;

                next->key = malloc(16);
                memcpy(next->key, chain + done, 16);

                keychain = next;
            }

            error = netmd_secure_send_key_data(devh, &ekb);
            puts(netmd_strerror(error));

            /* cleanup */
            free(ekb.signature);
            keychain = ekb.chain;
            while (keychain != NULL) {
                next = keychain->next;
                free(keychain->key);
                free(keychain);
                keychain = next;
            }

            /* exchange nonces */
            gcry_create_nonce(hostnonce, sizeof(hostnonce));
            error = netmd_secure_session_key_exchange(devh, hostnonce, devnonce);
            puts(netmd_strerror(error));

            /* calculate session key */
            retailmac(rootkey, hostnonce, devnonce, sessionkey);

            error = netmd_secure_setup_download(devh, contentid, kek, sessionkey);
            puts(netmd_strerror(error));

            /* read source */
            stat(argv[2], &stat_buf);
            data_size = (size_t)stat_buf.st_size;
            data = malloc(data_size);
            f = fopen(argv[2], "rb");
            fseek(f, 60, SEEK_CUR);
            fread(data, data_size - 60, 1, f);
            fclose(f);
            error = netmd_prepare_packets(data, data_size-60, &packets, &packet_count, kek);
            puts(netmd_strerror(error));

            /* send to device */
            error = netmd_secure_send_track(devh, NETMD_WIREFORMAT_LP2,
                                            NETMD_DISKFORMAT_LP2,
                                            (data_size - 60) / 192, packets,
                                            packet_count, sessionkey,
                                            &track, uuid, new_contentid);
            puts(netmd_strerror(error));

            /* cleanup */
            netmd_cleanup_packets(&packets);

            /* set title */
            netmd_log(NETMD_LOG_DEBUG, "New Track: %d\n", track);
            netmd_cache_toc(devh);
            netmd_set_title(devh, track, "test");
            netmd_sync_toc(devh);

            /* commit track */
            error = netmd_secure_commit_track(devh, track, sessionkey);
            puts(netmd_strerror(error));

            /* forget key */
            error = netmd_secure_session_key_forget(devh);
            puts(netmd_strerror(error));

            /* leave session */
            error = netmd_secure_leave_session(devh);
            puts(netmd_strerror(error));
        }
        else if(strcmp("help", argv[1]) == 0)
        {
            print_syntax();
        }
        else
        {
            print_disc_info(devh, md);
            print_syntax();
        }
    }
    else
        print_disc_info(devh, md);

    netmd_clean_disc_info(md);
    netmd_close(devh);
    netmd_clean(&device_list);

    return 0;
}
コード例 #20
0
ファイル: ping.c プロジェクト: pratikmankawde/HelenOS_Nano
int main(int argc, char *argv[])
{
	int rc;
	int argi;

	rc = inetping_init(&ev_ops);
	if (rc != EOK) {
		printf(NAME ": Failed connecting to internet ping service "
		    "(%d).\n", rc);
		return 1;
	}

	argi = 1;
	if (argi < argc && str_cmp(argv[argi], "-r") == 0) {
		ping_repeat = true;
		++argi;
	} else {
		ping_repeat = false;
	}

	if (argc - argi != 1) {
		print_syntax();
		return 1;
	}

	/* Parse destination address */
	rc = addr_parse(argv[argi], &dest_addr);
	if (rc != EOK) {
		printf(NAME ": Invalid address format.\n");
		print_syntax();
		return 1;
	}

	/* Determine source address */
	rc = inetping_get_srcaddr(&dest_addr, &src_addr);
	if (rc != EOK) {
		printf(NAME ": Failed determining source address.\n");
		return 1;
	}

	fid_t fid;

	if (ping_repeat) {
		fid = fibril_create(transmit_fibril, NULL);
		if (fid == 0) {
			printf(NAME ": Failed creating transmit fibril.\n");
			return 1;
		}

		fibril_add_ready(fid);

		fid = fibril_create(input_fibril, NULL);
		if (fid == 0) {
			printf(NAME ": Failed creating input fibril.\n");
			return 1;
		}

		fibril_add_ready(fid);
	} else {
		ping_send(1);
	}

	fibril_mutex_lock(&done_lock);
	rc = EOK;
	while (!done && rc != ETIMEOUT) {
		rc = fibril_condvar_wait_timeout(&done_cv, &done_lock,
			ping_repeat ? 0 : PING_TIMEOUT);
	}
	fibril_mutex_unlock(&done_lock);

	if (rc == ETIMEOUT) {
		printf(NAME ": Echo request timed out.\n");
		return 1;
	}

	return 0;
}