Ejemplo n.º 1
0
int main(int argc, char *argv[])
{
  char configFileName[255];
  const int pid = getpid();
  int createflag;
  extern int logflag, quietflag;
  int create_f, quiet_f;  /* log_f is a static global */

  createflag = logflag = quietflag = FALSE;
  create_f = log_f = quiet_f = FLAG_NOT_SET;

  // Begin command line parsing ***********************************************
  if (   (checkForOption("--help", argc, argv) != FLAG_NOT_SET)
      || (checkForOption("-h", argc, argv) != FLAG_NOT_SET)
      || (checkForOption("-help", argc, argv) != FLAG_NOT_SET) ) {
      print_help();
  }
  get_asf_share_dir_with_argv0(argv[0]);
  handle_license_and_version_args(argc, argv, ASF_NAME_STRING);

  // This is an undocumented option, for internal use (by the GUI)
  int save_dem = extract_flag_options(&argc, &argv, "-save-dem", "--save-dem", NULL);

  // Check which options were provided
  create_f = checkForOption("-create", argc, argv);
  log_f    = checkForOption("-log", argc, argv);
  quiet_f  = checkForOption("-quiet", argc, argv);

  // We need to make sure the user specified the proper number of arguments
  int needed_args = 1 + REQUIRED_ARGS;               // command & REQUIRED_ARGS
  int num_flags = 0;
  if (create_f != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option
  if (log_f    != FLAG_NOT_SET) {needed_args += 2; num_flags++;} // option & param
  if (quiet_f  != FLAG_NOT_SET) {needed_args += 1; num_flags++;} // option

  // Make sure we have the right number of args
  if(argc != needed_args) {
    print_usage();
  }

  // Make sure argument for each flag (that requires an arg) is not another
  // option flag & is not a required argument
  if (log_f != FLAG_NOT_SET) {
    if ( (argv[log_f+1][0]=='-') || (log_f>=(argc-REQUIRED_ARGS)) ) {
      print_usage();
    }
  }

  // Make sure all options occur before the config file name argument
  if (num_flags == 1 &&
      (create_f > 1 ||
       log_f    > 1 ||
       quiet_f  > 1))
  {
    print_usage();
  }
  else if (num_flags > 1 &&
           (create_f >= argc - REQUIRED_ARGS - 1 ||
            log_f    >= argc - REQUIRED_ARGS - 1 ||
            quiet_f  >= argc - REQUIRED_ARGS - 1))
  {
    print_usage();
  }

  // Do the actual flagging & such for each flag
  if (create_f != FLAG_NOT_SET) {
    createflag = TRUE;
  }
  if (log_f != FLAG_NOT_SET) {
    strcpy(logFile, argv[log_f+1]);
  }
  else {
    // default behavior: log to tmp<pid>.log
    sprintf(logFile, "tmp%i.log", pid);
  }
  logflag = TRUE;
  fLog = FOPEN(logFile, "a");
  // Set old school quiet flag (for use in our libraries)
  quietflag = quiet_f != FLAG_NOT_SET;

  // Fetch required arguments
  strcpy(configFileName, argv[argc-1]);

  // Report the command line
  asfSplashScreen(argc, argv);

  // End command line parsing *************************************************

  asf_convert_ext(createflag, configFileName, save_dem);

  // remove log file if we created it (leave it if the user asked for it)
  FCLOSE(fLog);
  if (log_f == FLAG_NOT_SET)
    remove(logFile);

  return(EXIT_SUCCESS);
}
Ejemplo n.º 2
0
static char *
do_convert(int pid, GtkTreeIter *iter, char *cfg_file, int save_dem,
           int keep_files, char **intermediates_file)
{
    FILE *output;
    char *logFile = appendExt(cfg_file, ".log");

    gtk_list_store_set(list_store, iter, COL_STATUS, "Processing...", -1);

#ifdef win32
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    memset(&si, 0, sizeof(si));
    memset(&pi, 0, sizeof(pi));
    si.cb = sizeof(si);

    char *cmd = MALLOC(sizeof(char)*
                       (strlen(cfg_file) + strlen(logFile) +
                        strlen(get_asf_bin_dir_win()) + 256));
    sprintf(cmd, "\"%s/asf_mapready.exe\" %s-log \"%s\" \"%s\"",
        get_asf_bin_dir_win(),
        save_dem ? "--save-dem " : "",
        logFile, cfg_file);

    fLog = fopen(logFile, "a");
    log_summary_text(fLog);
    FCLOSE(fLog);

    //printf("Running command> %s\n", cmd);
    if (!CreateProcess(NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
    {
        DWORD dw = GetLastError();
        //printf( "CreateProcess failed (%ld)\n", dw );

        LPVOID lpMsgBuf;
        FormatMessage(
          FORMAT_MESSAGE_ALLOCATE_BUFFER |
          FORMAT_MESSAGE_FROM_SYSTEM |
          FORMAT_MESSAGE_IGNORE_INSERTS,
          NULL,
          dw,
          MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
              (LPTSTR)&lpMsgBuf,
          0,
          NULL);

        printf("CreateProcess() failed with error %ld: %s\n",
            dw, (char*)lpMsgBuf);
        printf("Failed command: %s\n", cmd);
    }

    char *statFile = appendExt(cfg_file, ".status");
    DWORD dwWaitResult;
    int counter = 1;

    // now wait for process to finish
    do {
        while (gtk_events_pending())
            gtk_main_iteration();

        if (++counter % 200 == 0) {
            // check status file
            char buf[256];
            FILE *fStat = fopen(statFile, "r");
            if (fStat)
            {
                fgets(buf, sizeof(buf), fStat);
                fclose(fStat);

                gtk_list_store_set(list_store, iter, COL_STATUS, buf, -1);
            }
        }

        dwWaitResult = WaitForSingleObject(pi.hProcess, 50);
    }
    while (dwWaitResult == WAIT_TIMEOUT);

    remove_file(statFile);
    free(statFile);
    // Don't do this, CreateProcess() takes it
    //free(cmd);
#else
    extern int logflag;
    extern FILE *fLog;

    pid = fork();
    if (pid == 0)
    {
        /* child */
        logflag = TRUE;
        fLog = fopen(logFile, "a");

        asfPrintStatus("Running MapReady with configuration file: %s\n",
                       cfg_file);

        log_summary_text(fLog);

        asf_convert_ext(FALSE, cfg_file, save_dem);

        FCLOSE(fLog);
        exit(EXIT_SUCCESS);
    }
    else
    {
        /* parent */
        int counter = 1;
        char *statFile = appendExt(cfg_file, ".status");
        while (waitpid(pid, NULL, WNOHANG) == 0)
        {
            while (gtk_events_pending())
                gtk_main_iteration();

            g_usleep(50);

            if (++counter % 200 == 0) {
                /* check status file */
                char buf[256];
                FILE *fStat = fopen(statFile, "r");
                if (fStat)
                {
                    if (fgets(buf, sizeof(buf), fStat))
                        fclose(fStat);
                    else
                        strcpy(buf,"");

                    gtk_list_store_set(list_store, iter, COL_STATUS, buf, -1);

                    if (strcmp(buf, "Done")==0 || strcmp(buf, "Error")==0) {
                         // kludge:
                         // Status file says "Done" but we're still here.
                         // This could happen because it *just* finished
                         // during the most recent g_usleep(), but a much more
                         // likely reason is that the waitpid() detection
                         // failed.  (I say "much more likely" because waitpid
                         // is checked 200x more often than the status file)

                         // UPDATE!
                         // We figured out why this is occurring on Linux,
                         // it is a bug in the GtkFileChooser.  Since the
                         // chooser is much nicer than the older FileSelector,
                         // we'll keep this kludge... seems to be no other
                         // side effects... hopefully...

                         // Expanded the kludge to update the status file
                         // with "Error", so that even if the process exits
                         // with an error we'll still be ok.  This only
                         // leaves the core-dump case as a loose end.

#ifdef linux
                         // On Linux (which is actually the only platform
                         // I have seen this problem), we can try to kill
                         // the zombie process.
                         kill(pid, 9);
#endif

                         // We'll break out of the loop now, and
                         // possibly leave a zombie process around, if this
                         // were to occur somewhere other than Linux
                         break;
                     }
                }
            }
        }

        remove_file(statFile);
        free(statFile);
    }
#endif

    gchar *the_output = NULL;
    output = fopen(logFile, "r");

    // see if we got a file containing a list of useful intermediate files
    *intermediates_file = appendExt(cfg_file, ".files");
    if (!fileExists(*intermediates_file)) {
      free(*intermediates_file);
      *intermediates_file = NULL;
    }

    if (!output)
    {
        the_output = (gchar *)g_malloc(512);
        sprintf(the_output, "Error Opening Log File: %s\n", strerror(errno));
    }
    else
    {
        gchar buffer[4096];
        gchar *p = fgets(buffer, sizeof(buffer), output);
        while (!feof(output))
        {
            if (p && !g_str_has_prefix(p, "Processing "))
            {
                if (the_output)
                {
                    the_output = (gchar *)g_realloc(the_output, sizeof(gchar) *
                        (strlen(the_output) + strlen(buffer) + 1));

                    strcat(the_output, buffer);
                }
                else
                {
                    the_output = (gchar *)
                        g_malloc(sizeof(gchar) * (strlen(buffer) + 1));

                    strcpy(the_output, buffer);
                }
            }
            p = fgets(buffer, sizeof(buffer), output);
        }
        fclose(output);

        if (!keep_files)
            remove_file(logFile);
    }

    if (!the_output)
    {
        /* Log file existed, but had immediate EOF */
        /* This is most likely caused by a "Disk Full" situation... */
        /*  ... or a segmentation fault! */
        the_output = g_strdup("Error Opening Log File: Disk Full?\n");
    }

    free(logFile);
    return the_output;
}