Beispiel #1
0
uint8_t _concat(char *filename, char **inputs, uint16_t ninputs) {

  uint16_t i;
  int      size;
  uint8_t *buf;
  FILE    *outf;
  FILE    *inf;
  char    *infname;

  buf       = NULL;
  outf      = NULL;
  inf       = NULL;

  filename = set_suffix(filename, "img");
  if (filename == NULL) goto fail;
  
  outf = fopen(filename, "wb");
  if (outf == NULL) goto fail;

  for (i = 0; i < ninputs; i++, inf = NULL, buf = NULL) {

    infname = set_suffix(inputs[i], "img");
    if (infname == NULL) goto fail;

    inf = fopen(infname, "rb");
    if (inf == NULL) goto fail;

    size = filesize(inf);
    buf  = malloc(size);

    if (buf == NULL) goto fail;

    if (fread( buf, 1, size, inf)  != size) goto fail;
    if (fwrite(buf, 1, size, outf) != size) goto fail;

    fclose(inf);
    free(buf);
    free(infname);
    infname = NULL;
    inf     = NULL;
  }
 
  fclose(outf);
  free(filename);
  return 0;

 fail:
  if (outf     != NULL) fclose(outf);
  if (inf      != NULL) fclose(inf);
  if (filename != NULL) free(filename);
  if (buf      != NULL) free(buf);
  return 1;
}
Beispiel #2
0
static bool parse_suffixes(w_query *res, json_t *query)
{
  json_t *suffixes;
  size_t i;

  suffixes = json_object_get(query, "suffix");
  if (!suffixes) {
    return true;
  }

  if (json_is_string(suffixes)) {
    json_t *ele = suffixes;
    res->nsuffixes = 1;
    res->suffixes = calloc(res->nsuffixes, sizeof(w_string_t*));
    return set_suffix(res, ele, res->suffixes);
  }

  if (!json_is_array(suffixes)) {
    res->errmsg = strdup("'suffix' must be a string or an array of strings");
    return false;
  }

  res->nsuffixes = json_array_size(suffixes);
  res->suffixes = calloc(res->nsuffixes, sizeof(w_string_t*));

  if (!res->suffixes) {
    return false;
  }

  for (i = 0; i < json_array_size(suffixes); i++) {
    json_t *ele = json_array_get(suffixes, i);

    if (!json_is_string(ele)) {
      res->errmsg = strdup("'suffix' must be a string or an array of strings");
      return false;
    }

    if (!set_suffix(res, ele, res->suffixes + i)) {
      return false;
    }
  }

  return true;
}
Beispiel #3
0
char *
mkbak (const char *filename, backup_t type)
{
  static char buf[FILENAME_MAX];

  if (access (filename, R_OK) != 0)
    return (char *) filename;

  strcpy (buf, filename);
  set_suffix (buf, ".bak");
  if (strcmp (filename, buf) != 0)
    {
      remove (buf);                             // *try* to remove or rename() will fail
      if (rename (filename, buf))               // keep file attributes like date, etc.
        {
          fprintf (stderr, "ERROR: Can't rename \"%s\" to \"%s\"\n", filename, buf);
          exit (1);
        }
    }
  else // handle the case where filename has the suffix ".bak".
    {
      char buf2[FILENAME_MAX];

      if (!dirname2 (filename, buf))
        {
          fprintf (stderr, "INTERNAL ERROR: dirname2() returned NULL\n");
          exit (1);
        }
      if (buf[0] != 0)
        if (buf[strlen (buf) - 1] != FILE_SEPARATOR)
          strcat (buf, FILE_SEPARATOR_S);

      strcat (buf, basename2 (tmpnam2 (buf2)));
      if (rename (filename, buf))
        {
          fprintf (stderr, "ERROR: Can't rename \"%s\" to \"%s\"\n", filename, buf);
          exit (1);
        }
    }

  switch (type)
    {
    case BAK_MOVE:
      return buf;

    case BAK_DUPE:
    default:
      if (fcopy (buf, 0, fsizeof (buf), filename, "wb"))
        {
          fprintf (stderr, "ERROR: Can't open \"%s\" for writing\n", filename);
          exit (1);
        }
      sync ();
      return buf;
    }
}
Beispiel #4
0
uint8_t nifti1_load_hdr(char *filename, nifti1_hdr_t *hdr) {

  FILE    *f;
  int      sz;
  uint8_t *bytes;
  char    *afile;

  f     = NULL;
  bytes = NULL;
  afile = NULL;

  memset(hdr, 0, sizeof(nifti1_hdr_t));

  afile = set_suffix(filename, "hdr");
  if (afile == NULL) goto fail;

  f = fopen(afile, "rb");
  if (f == NULL) goto fail;

  sz = filesize(f);
  if (sz != 348 && sz != 352) goto fail;

  bytes = malloc(sz);
  if (bytes == NULL) goto fail;

  if (fread(bytes, 1, sz, f) != sz) goto fail;

  memcpy(hdr, bytes, sz);

  if (hdr->dim[0] > 7) {

    nifti1_reverse_hdr(hdr);

    if (hdr->dim[0]     >  7)   goto fail;
    if (hdr->sizeof_hdr != 348) goto fail;

    hdr->rev = 1;
  }

  fclose(f);
  free(bytes);
  free(afile);
  return 0;

fail:
  if (f     != NULL) fclose(f);
  if (bytes != NULL) free(bytes);
  if (afile != NULL) free(afile);
  return 1;
}
Beispiel #5
0
int
lynx_lnx (st_rominfo_t *rominfo)
{
  st_lnx_header_t header;
  char dest_name[FILENAME_MAX];
  int size = ucon64.file_size;

  if (rominfo->buheader_len != 0)
    {
      fprintf (stderr, "ERROR: This seems to already be an LNX file\n\n");
      return -1;
    }

  header.page_size_bank0 = size > 4 * MBIT ? 4 * MBIT / 256 : size / 256;
  header.page_size_bank1 = size > 4 * MBIT ? (size - (4 * MBIT)) / 256 : 0;
#ifdef  WORDS_BIGENDIAN
  header.page_size_bank0 = bswap_16 (header.page_size_bank0);
  header.page_size_bank1 = bswap_16 (header.page_size_bank1);
#endif

  memset (header.cartname, 0, sizeof (header.cartname));
  memset (header.manufname, 0, sizeof (header.manufname));
  memset (header.spare, 0, sizeof (header.spare));

#ifdef  WORDS_BIGENDIAN
  header.version = bswap_16 (1);
#else
  header.version = 1;
#endif

  memcpy (header.magic, "LYNX", 4);
  header.rotation = 0;
  strncpy (header.cartname, ucon64.rom, sizeof (header.cartname));
  strcpy (header.manufname, "Atari");

  strcpy (dest_name, ucon64.rom);
  set_suffix (dest_name, ".lnx");

  ucon64_file_handler (dest_name, NULL, 0);
  ucon64_fwrite (&header, 0, sizeof (st_lnx_header_t), dest_name, "wb");
  fcopy (ucon64.rom, 0, ucon64.file_size, dest_name, "ab");

  printf (ucon64_msg[WROTE], dest_name);
  return 0;
}
Beispiel #6
0
// header format is specified in src/backup/ffe.h
int
pce_msg (st_ucon64_nfo_t *rominfo)
{
  char src_name[FILENAME_MAX], dest_name[FILENAME_MAX];
  unsigned char *rom_buffer = NULL;
  st_msg_header_t header;
  int size = ucon64.file_size - rominfo->backup_header_len;

  if (rominfo->interleaved)
    if ((rom_buffer = (unsigned char *) malloc (size)) == NULL)
      {
        fprintf (stderr, ucon64_msg[ROM_BUFFER_ERROR], size);
        return -1;
      }

  memset (&header, 0, MSG_HEADER_LEN);
  header.size = (unsigned char) (size / 8192);
  header.emulation = size == 3 * MBIT ? 1 : 0;
  header.id1 = 0xaa;
  header.id2 = 0xbb;
  header.type = 2;

  strcpy (src_name, ucon64.fname);
  strcpy (dest_name, ucon64.fname);
  set_suffix (dest_name, ".msg");
  ucon64_file_handler (dest_name, src_name, 0);

  ucon64_fwrite (&header, 0, MSG_HEADER_LEN, dest_name, "wb");
  if (rominfo->interleaved)
    {
      // Magic Super Griffin files should not be "interleaved"
      ucon64_fread (rom_buffer, rominfo->backup_header_len, size, src_name);
      swapbits (rom_buffer, size);
      ucon64_fwrite (rom_buffer, MSG_HEADER_LEN, size, dest_name, "ab");
      free (rom_buffer);
    }
  else
    fcopy (src_name, rominfo->backup_header_len, size, dest_name, "ab");

  printf (ucon64_msg[WROTE], dest_name);
  remove_temp_file ();
  return 0;
}
Beispiel #7
0
int
lynx_lyx (st_rominfo_t *rominfo)
{
  char dest_name[FILENAME_MAX];

  if (!rominfo->buheader_len)
    {
      fprintf (stderr, "ERROR: This is no LNX file\n\n");
      return -1;
    }

  strcpy (dest_name, ucon64.rom);
  set_suffix (dest_name, ".lyx");

  ucon64_file_handler (dest_name, NULL, 0);
  fcopy (ucon64.rom, rominfo->buheader_len, ucon64.file_size, dest_name, "wb");

  printf (ucon64_msg[WROTE], dest_name);
  return 0;
}
Beispiel #8
0
    void FSName::set_name(const char* file_name, const char* suffix, const int32_t cluster_id)
    {
      file_name_[0] = '\0';
      cluster_id_ = cluster_id;
      memset(&filev1_, 0, sizeof(FileBitsV1));
      memset(&filev2_, 0, sizeof(FileBitsV2));

      if (NULL != file_name && file_name[0] != '\0')
      {
        TfsFileType file_type = check_file_type(file_name);
        if (INVALID_TFS_FILE_TYPE == file_type)
        {
          is_valid_ = false;
        }
        else
        {
          int32_t file_name_len = 0;
          if (TFS_FILE_NAME_V1 == version_)
          {
            file_name_len = FILE_NAME_LEN;
            decode(file_name + 2, (char*) &filev1_, file_name_len - 2);
          }
          else
          {
            file_name_len = FILE_NAME_LEN_V2;
            decode(file_name + 3, (char*) &filev2_, file_name_len - 3);
          }

          if (NULL == suffix)
          {
            suffix = file_name + file_name_len;
          }
          set_suffix(suffix);
          if (0 == cluster_id_)
          {
            cluster_id_ = file_name[1] - '0';
          }
        }
      }
    }
Beispiel #9
0
// based on sourcecode of MakePPF v2.0 Linux/Unix by Icarus/Paradox
int
ppf_create (const char *orgname, const char *modname)
{
    FILE *orgfile, *modfile, *ppffile;
    char ppfname[FILENAME_MAX], buffer[MAX_ID_SIZE], obuf[512], mbuf[512];
#if 0
    char *fidname = "FILE_ID.DIZ";
#endif
    int x, osize, msize, blocksize, n_changes, total_changes = 0;
    unsigned int seekpos = 0, pos;

    osize = fsizeof (orgname);
    msize = fsizeof (modname);
#ifndef DIFF_FSIZE
    if (osize != msize)
    {
        fprintf (stderr, "ERROR: File sizes do not match\n");
        return -1;
    }
#endif

    if ((orgfile = fopen (orgname, "rb")) == NULL)
    {
        fprintf (stderr, ucon64_msg[OPEN_READ_ERROR], orgname);
        exit (1);
    }
    if ((modfile = fopen (modname, "rb")) == NULL)
    {
        fprintf (stderr, ucon64_msg[OPEN_READ_ERROR], modname);
        exit (1);
    }
    strcpy (ppfname, modname);
    set_suffix (ppfname, ".ppf");
    ucon64_file_handler (ppfname, NULL, 0);
    if ((ppffile = fopen (ppfname, "wb")) == NULL)
    {
        fprintf (stderr, ucon64_msg[OPEN_WRITE_ERROR], ppfname);
        exit (1);
    }

    // creating PPF 2.0 header
    fwrite ("PPF20", 5, 1, ppffile);              // magic
    fputc (1, ppffile);                           // encoding method
    memset (buffer, ' ', 50);
    fwrite (buffer, 50, 1, ppffile);              // description line
#ifdef  WORDS_BIGENDIAN
    x = bswap_32 (osize);
    fwrite (&x, 4, 1, ppffile);
#else
    fwrite (&osize, 4, 1, ppffile);               // orgfile size
#endif
    fseek (orgfile, 0x9320, SEEK_SET);
    memset (buffer, 0, 1024);                     // one little hack that makes PPF
    fread (buffer, 1024, 1, orgfile);             //  suitable for files < 38688 bytes
    fwrite (buffer, 1024, 1, ppffile);            // 1024 byte block

    printf ("Writing patch data, please wait...\n");
    // finding changes
    fseek (orgfile, 0, SEEK_SET);
    fseek (modfile, 0, SEEK_SET);
    while ((blocksize = fread (obuf, 1, 255, orgfile)))
    {
        blocksize = fread (mbuf, 1, blocksize, modfile);
#ifdef  DIFF_FSIZE
        if (blocksize == 0)
            break;
#endif
        pos = seekpos;
        x = 0;
        while (x != blocksize)
        {
            if (obuf[x] != mbuf[x])
            {
                pos = seekpos + x;
                n_changes = 0;
                do
                {
                    buffer[n_changes] = mbuf[x];
                    n_changes++;
                    x++;
                }
                while (x != blocksize && obuf[x] != mbuf[x]);
                total_changes += n_changes;
#ifdef  WORDS_BIGENDIAN
                pos = bswap_32 (pos);
#endif
                fwrite (&pos, 4, 1, ppffile);
                fputc (n_changes, ppffile);
                fwrite (buffer, n_changes, 1, ppffile);
            }
            else
                x++;
        }
        seekpos += blocksize;
    }

#ifdef  DIFF_FSIZE
    if (msize > osize)
    {
        pos = seekpos;
        while ((blocksize = fread (buffer, 1, 255, modfile)))
        {
            total_changes += blocksize;
#ifdef  WORDS_BIGENDIAN
            x = bswap_32 (pos);
            fwrite (&x, 4, 1, ppffile);
#else
            fwrite (&pos, 4, 1, ppffile);
#endif
            fputc (blocksize, ppffile);
            fwrite (buffer, blocksize, 1, ppffile);
            pos += blocksize;
        }
    }
    else if (msize < osize)
        printf ("WARNING: %s is smaller than %s\n"
                "         PPF can't store information about that fact\n",
                modname, orgname);
#endif

    fclose (orgfile);
    fclose (modfile);

    if (total_changes == 0)
    {
        printf ("%s and %s are identical\n"
                "Removing: %s\n", orgname, modname, ppfname);
        fclose (ppffile);
        remove (ppfname);
        return -1;
    }

#if 0
    if (fidname)
    {
        int fsize = fsizeof (fidname);
        if (fsize > MAX_ID_SIZE)
            fsize = MAX_ID_SIZE;                    // File id only up to 3072 bytes!
        printf ("Adding FILE_ID.DIZ (%s)...\n", fidname);
        ucon64_fread (buffer, 0, fsize, fidname);
        fwrite ("@BEGIN_FILE_ID.DIZ", 18, 1, ppffile);
        fwrite (buffer, fsize, 1, ppffile);
        fwrite ("@END_FILE_ID.DIZ", 16, 1, ppffile);
#ifdef  WORDS_BIGENDIAN
        fsize = bswap_32 (fsize);                 // Write file size in little-endian format
#endif
        fwrite (&fsize, 4, 1, ppffile);
    }
#endif
    fclose (ppffile);

    printf (ucon64_msg[WROTE], ppfname);
    return 0;
}
Beispiel #10
0
int
property_check (const char *filename, int version, int verbose)
{
  char buf[MAXBUFSIZE];
  const char *p = NULL;
  int result = 0;

  if (access (filename, F_OK) != 0)
    {
      FILE *fh = NULL;

      if (verbose) 
        {
          fprintf (stderr, "NOTE: %s not found: creating...", filename);
          fflush (stderr);
        }

      if (!(fh = fopen (filename, "w"))) // opening the file in text mode
        {                                         //  avoids trouble under DOS
          printf ("FAILED\n\n");
          return -1;
        }
      fclose (fh);                              // we'll use set_property() from now
    }
  else
    {
      p = get_property (filename, "version", PROPERTY_MODE_TEXT);
      if (strtol (p ? p : "0", NULL, 10) >= version)
        return 0; // OK

      strcpy (buf, filename);
      set_suffix (buf, ".old");

      if (verbose)
        {
          fprintf (stderr, "NOTE: updating config: will be renamed to %s...", buf);
          fflush (stderr);
        }

      rename (filename, buf);
    }

  // store new version
  sprintf (buf, "%d", version);
  result = set_property (filename, "version", buf, "configfile version (do NOT edit)");

  if (result > 0)
    {
      if (verbose)
        fprintf (stderr, "OK\n\n");
    }
  else
    {
      if (verbose)
        fprintf (stderr, "FAILED\n\n");

      // remove the crap
      remove (filename);
    }

  if (verbose)
    fflush (stderr);

  return 1;
}
Beispiel #11
0
int
main (int argc, char **argv)
{
//  int i = 0;
//  char buf[MAXBUFSIZE];
  int c = 0, option_index = 0;
  int x = 0, y = 0;
  struct option long_only_options[ARGS_MAX];
  int result = 0;
//  const char *p = NULL; 
  const st_property_t props[] =
    {
      {
        "ansi_color", "1",
        "use ANSI colors in output? (1=yes; 0=no)"
      },
      {
        "default_cmdline", "",
        "will be used when quh is started w/o args"
      },
      {
        "settings", "100",
        "internal settings like volume, etc."
      },
#if 0
      {
        "quh_configdir",
        PROPERTY_MODE_DIR ("quh"),
        "directory with additional config files"
      },
#endif
      {NULL, NULL, NULL}
    };

  memset (&quh, 0, sizeof (st_quh_t));

  // defaults
  quh.pid = 1;
  tmpnam3 (quh.tmp_file, 0);
  set_suffix (quh.tmp_file, ".wav");

  if(!(quh.o = cache_open (MAXBUFSIZE, CACHE_MEM|CACHE_LIFO)))
    {
      fprintf (stderr, "ERROR: Could not malloc %d bytes\n", MAXBUFSIZE);
      return -1;
    }

  realpath2 (PROPERTY_HOME_RC ("quh"), quh.configfile);

  result = property_check (quh.configfile, QUH_CONFIG_VERSION, 1);
  if (result == 1) // update needed
    result = set_property_array (quh.configfile, props);
  if (result == -1) // property_check() or update failed
    return -1;

  signal (SIGINT, quh_signal_handler);
  signal (SIGTERM, quh_signal_handler);

  atexit (quh_exit);

  quh.ansi_color = get_property_int (quh.configfile, "ansi_color");
  quh.settings = get_property_int (quh.configfile, "settings");

  quh.argc = argc;
  quh.argv = argv;

#if 0
  // memorize cmdline
  if (quh.argc > 2)
    { 
      for (; quh.argv[i] && i < quh.argc; i++)
        sprintf (strchr (buf, 0), "%s ", quh.argv[i]);

      set_property (quh.configfile, "default_cmdline", buf,
                    "will be used when quh is started w/o args");
    }
  else
    {
      p = get_property (quh.configfile, "default_cmdline", PROPERTY_MODE_TEXT);

      if (p)
        { 
          strncpy (buf, p, MAXBUFSIZE)[MAXBUFSIZE - 1] = 0;
          quh.argc = strarg (quh.argv, buf, " ", QUH_MAX_ARGS);
        }
    }
#endif

  // set default filter chain
  filters = 0;
  quh.filter_id[filters++] = QUH_CACHE_PASS;
  quh.filter_id[filters++] = QUH_CONSOLE_PASS;
#ifdef  USE_ID3
//  quh.filter_id[filters++] = QUH_ID3_IN;
#endif
//  quh.filter_id[filters++] = QUH_CDDB_IN;
#ifdef  USE_OSS
  quh.filter_id[filters++] = QUH_OSS_OUT;
#elif   defined USE_SDL
  quh.filter_id[filters++] = QUH_SDL_OUT;
#endif

  // convert (st_getopt2_t **) to (st_getopt2_t *)
  memset (&options, 0, sizeof (st_getopt2_t) * QUH_MAX_ARGS);
  for (c = x = 0; option[x]; x++)
    for (y = 0; option[x][y].name || option[x][y].help; y++)
      if (c < QUH_MAX_ARGS)
        {
          memcpy (&options[c], &option[x][y], sizeof (st_getopt2_t));
          c++;
        }

#if 0
  for (x = 0; quh_decode_usage[x]; x++)
    if (c < QUH_MAX_ARGS)
      {
        memcpy (&options[c], quh_decode_usage[x], sizeof (st_getopt2_t));
        c++;
      }
#endif

  for (x = 0; quh_filter_usage[x]; x++)
    if (c < QUH_MAX_ARGS)
      {
        memcpy (&options[c], quh_filter_usage[x], sizeof (st_getopt2_t));
        c++;
      }

  for (x = 0; option2[x]; x++)
    for (y = 0; option2[x][y].name || option2[x][y].help; y++)
      if (c < QUH_MAX_ARGS)
        {
          memcpy (&options[c], &option2[x][y], sizeof (st_getopt2_t));
          c++;
        }

  getopt2_long_only (long_only_options, options, ARGS_MAX);

#if 0
  // if no options or filenames were specified we use a default cmdline
  if (argc < 2) // || !optind)
    {
      p = get_property (quh.configfile, "default_cmdline", PROPERTY_MODE_TEXT);
      if (p)
        {
          strncpy (quh.cmdline, p, ARGS_MAX)[ARGS_MAX - 1] = 0;
          quh.argc = strarg (quh.argv, quh.cmdline, " ", QUH_MAX_ARGS);
        }
    }
  else // store cmdline
    {
      strcpy (quh.cmdline, argv[0]);
      for (x = 1; x < argc; x++)
        sprintf (strchr (quh.cmdline, 0), " \"%s\"", quh.argv[x]);
      set_property (quh.configfile, "default_cmdline", quh.cmdline, NULL);
    }

  for (x = 0; x < quh.argc; x++)
    printf ("quh.argv[%d] == %s\n", x, quh.argv[x]);
  fflush (stdout);
#endif

  while ((c = getopt_long_only (quh.argc, quh.argv, "", long_only_options, &option_index)) != -1)
    quh_opts (c);

//  if (quh.verbose)
  if (!quh.quiet)
    fputs ("Quh " QUH_VERSION_S " 'Having ears makes sense again' 2005-2006 by NoisyB\n"
           "This may be freely redistributed under the terms of the GNU Public License\n\n", stdout);

  if (quh.argc < 2) // || !optind)
    {
      getopt2_usage (options);
      return -1;
    }

#warning files?
#if 0
  if (!getfile (quh.argc, quh.argv, quh_set_fname,
                (GETFILE_FILES_ONLY | (quh.flags & QUH_RECURSIVE ? GETFILE_RECURSIVE : 0)))) // recursively?
    {
      if (!quh.quiet)
        getopt2_usage (options);
      return -1;
    }
#endif

  if (!quh.filter_id[0])
    {
      fputs ("ERROR: you haven't specified any filters\n", stderr);
      fflush (stderr);
      return -1;
    }

  if (!quh.files)
    {
      fputs ("ERROR: you haven't specified any files to play\n", stderr);
      fflush (stderr);
      return -1;
    }

  if (!(quh.filter_chain = filter_malloc_chain (quh_filter)))
    {
      fputs ("ERROR: filter_malloc_chain() failed\n", stderr);
      fflush (stderr);
      return -1;
    }

  if (filter_init (quh.filter_chain, NULL, NULL) == -1)
    {
      fputs ("ERROR: filter_init() failed\n", stderr);
      fflush (stderr);
      return -1;
    }

  quh_play ();

  return 0;
}