/* misc.c

 *

 * Copyright (C) 1996-2025 Timo Kokkonen

 * All Rights Reserved.

 *

 * SPDX-License-Identifier: GPL-3.0-or-later

 *

 * This file is part of JPEGoptim.

 *

 * JPEGoptim is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 *

 * JPEGoptim is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with JPEGoptim. If not, see <https://www.gnu.org/licenses/>.

 */

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <stdio.h>

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <string.h>

#include <stdarg.h>

#include <stdlib.h>

#include <time.h>

#include "jpegoptim.h"

FILE* create_file(const char *name)

{

  FILE *f;

  int fd;

  if (!name)

    return NULL;

#ifdef WIN32

  fd = open(name, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, _S_IREAD | _S_IWRITE);

#else

  fd = open(name, O_WRONLY | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR);

#endif

  if (fd < 0)

    return NULL;

  if (!(f = fdopen(fd, "wb"))) {

    close(fd);

    return NULL;

  }

  return f;

}

FILE *create_temp_file(const char *tmpdir, const char *name, char *filename, size_t filename_len)

{

  FILE *f;

  int newlen;

#ifdef HAVE_MKSTEMPS

  /* Rely on mkstemps() to create us temporary file safely... */

  newlen = snprintf(filename, filename_len, "%s%s-%u-%u.XXXXXX.tmp",

      tmpdir, name, getuid(), getpid());

#else

  /* If platform is missing mkstemps(), try to create at least somewhat "safe" temp file... */

  newlen = snprintf(filename, filename_len, "%s%s-%u-%u.%lu.tmp",

      tmpdir, name, getuid(), getpid(), (unsigned long)time(NULL));

#endif

  if (newlen >= filename_len) {

    warn("temp filename too long: %s", filename);

    return NULL;

  }

#ifdef HAVE_MKSTEMPS

  int tmpfd = mkstemps(filename, 4);

  if (tmpfd < 0) {

    warn("error creating temp file: mkstemps('%s', 4) failed", filename);

    return NULL;

  }

  f = fdopen(tmpfd, "wb");

#else

  f = create_file(filename);

#endif

  return f;

}

int delete_file(const char *name)

{

  int retval;

  if (!name)

    return -1;

  if (verbose_mode > 1 && !quiet_mode)

    fprintf(stderr,"deleting: %s\n",name);

  if ((retval=unlink(name)) && !quiet_mode)

    warn("error removing file: %s",name);

  return retval;

}

long file_size(FILE *fp)

{

  struct stat buf;

  if (!fp)

    return -1;

  if (fstat(fileno(fp),&buf) != 0)

    return -2;

  return (long)buf.st_size;

}

int is_directory(const char *pathname)

{

  struct stat buf;

  if (!pathname)

    return 0;

  if (stat(pathname,&buf) != 0)

    return 0;

  return (S_ISDIR(buf.st_mode) ? 1 : 0);

}

int is_file(const char *filename, struct stat *st)

{

  struct stat buf;

  if (!filename)

    return 0;

  if (lstat(filename,&buf) != 0)

    return 0;

  if (st)

    *st=buf;

  return (S_ISREG(buf.st_mode) ? 1 : 0);

}

int file_exists(const char *pathname)

{

  struct stat buf;

  if (!pathname)

    return 0;

  return (stat(pathname,&buf) == 0 ? 1 : 0);

}

int rename_file(const char *old_path, const char *new_path)

{

  if (!old_path || !new_path)

    return -1;

#ifdef WIN32

  if (file_exists(new_path))

    delete_file(new_path);

#endif

  return rename(old_path,new_path);

}

#define COPY_BUF_SIZE  (256 * 1024)

int copy_file(const char *srcfile, const char *dstfile)

{

  FILE *in,*out;

  unsigned char *buf;

  int r,w;

  int err=0;

  if (!srcfile || !dstfile)

    return -1;

  if (!(in = fopen(srcfile, "rb"))) {

    warn("failed to open file for reading: %s", srcfile);

    return -2;

  }

  if (!(out = create_file(dstfile))) {

    fclose(in);

    warn("failed to open file for writing: %s", dstfile);

    return -3;

  }

  if (!(buf = calloc(COPY_BUF_SIZE, 1)))

    fatal("out of memory");

  do {

    r = fread(buf, 1, COPY_BUF_SIZE, in);

    if (r > 0) {

      w = fwrite(buf, 1, r, out);

      if (w != r) {

        err=1;

        warn("error writing to file: %s", dstfile);

        break;

      }

    } else {

      if (ferror(in)) {

        err=2;

        warn("error reading from file: %s", srcfile);

        break;

      }

    }

  } while (!feof(in));

  fclose(out);

  fclose(in);

  free(buf);

  return err;

}

char *fgetstr(char *s, size_t size, FILE *stream)

{

  char *p;

  if (!s || size < 1 || !stream)

    return NULL;

  if (!fgets(s, size, stream))

    return NULL;

  p = s + strnlen(s, size) - 1;

  while ((p >= s) && ((*p == 10) || (*p == 13)))

    *p--=0;

  return s;

}

char *splitdir(const char *pathname, char *buf, size_t size)

{

  char *s;

  int len = 0;

  if (!pathname || !buf || size < 1)

    return NULL;

  if ((s = strrchr(pathname, DIR_SEPARATOR_C)))

    len = (s - pathname) + 1;

  if (len >= size)

    return NULL;

  if (len > 0)

    memcpy(buf, pathname, len);

  buf[len] = 0;

  return buf;

}

char *splitname(const char *pathname, char *buf, size_t size)

{

  const char *s = NULL;

  int len;

  if (!pathname || !buf || size < 1)

    return NULL;

  if ((s = strrchr(pathname, DIR_SEPARATOR_C)))

    s++;

  else

    s=pathname;

  if ((len = strlen(s)) >= size)

    return NULL;

  if (len > 0)

    memcpy(buf, s, len);

  buf[len] = 0;

  return buf;

}

char *strncopy(char *dst, const char *src, size_t size)

{

  if (!dst || !src || size < 1)

    return dst;

  if (size > 1)

    strncpy(dst, src, size - 1);

  dst[size - 1] = 0;

  return dst;

}

char *strncatenate(char *dst, const char *src, size_t size)

{

  int used, free;

  if (!dst || !src || size < 1)

    return dst;

  /* Check if dst string is already "full" ... */

  used = strnlen(dst, size);

  if ((free = size - used) <= 1)

    return dst;

  return strncat(dst + used, src, free - 1);

}

char *str_add_list(char *dst, size_t size, const char *src, const char *delim)

{

  if (!dst || !src || !delim || size < 1)

    return dst;

  if (strnlen(dst, size) > 0)

    strncatenate(dst, delim, size);

  return strncatenate(dst, src, size);

}

void fatal(const char *format, ...)

{

  va_list args;

  fprintf(stderr, PROGRAMNAME ": ");

  va_start(args,format);

  vfprintf(stderr, format, args);

  va_end(args);

  fprintf(stderr,"\n");

  fflush(stderr);

  exit(3);

}

void warn(const char *format, ...)

{

  va_list args;

  if (quiet_mode) return;

  fprintf(stderr, PROGRAMNAME ": ");

  va_start(args,format);

  vfprintf(stderr, format, args);

  va_end(args);

  fprintf(stderr,"\n");

  fflush(stderr);

}

/* eof :-) */