Beispiel #1
0
static void
start(Test *t)
{
    t->fd = tmpfd();
    strcpy(t->dir, TmpDirPat);
    mktemp(t->dir);
    t->pid = fork();
    if (t->pid < 0) {
        die(1, errno, "fork");
    } else if (!t->pid) {
        setpgid(0, 0);
        if (dup2(t->fd, 1) == -1) {
            die(3, errno, "dup2");
        }
        if (close(t->fd) == -1) {
            die(3, errno, "fclose");
        }
        if (dup2(1, 2) == -1) {
            die(3, errno, "dup2");
        }
        curdir = t->dir;
        t->f();
        _exit(0);
    }
    setpgid(t->pid, t->pid);
}
Beispiel #2
0
void runSuccess() {
    char buf[] = "temp";
    //@ assert \valid(buf+(0..\block_length(buf)-1));
    //@ assert \exists integer x; buf[x] == '\0';

    mktemp(buf);
}
Beispiel #3
0
int main(int argc, string argv[])
{
  string *mdtab, *names, *exprs, prog;
  int nexp = 0, i, j;

  initparam(argv, defv);
  mdtab = getmapdefs();				// get list of mapping vars
  for (i = 0; mdtab[i] != NULL; i += 2)
    if (getparamstat(mdtab[i]) & ARGPARAM)	// if var has assigned value
      nexp++;
  eprintf("[%s: %scounted %d variable assignments]\n", getprog(),
	  nexp > 0 ? "" : "warning: ", nexp);
  names = (string *) allocate(sizeof(string *) * (nexp + 1));
  exprs = (string *) allocate(sizeof(string *) * (nexp + 1));
  for (i = j = 0; mdtab[i] != NULL; i += 2)
    if (getparamstat(mdtab[i]) & ARGPARAM) {	// if var has assigned value
      exprs[j] = getparam(mdtab[i]);		// list value given as expr
      names[j] = mdtab[i+1];			// and name of access macro
      j++;
    }
  exprs[j] = names[j] = NULL;
  prog = mktemp((string) copxstr("/tmp/sm_XXXXXX", sizeof(char)));
  buildmap(prog, names, exprs, NULL,
	   strnull(getparam("t")) ? NULL : getparam("t"),
	   Precision, NDIM, TRUE);
  execmap(prog);
  if (unlink(prog) != 0)
    error("%s: can't unlink %s\n", getargv0(), prog);
  return (0);
}
Beispiel #4
0
char *tempnam( char *dir, char *pfx )
{
    char	*s;

    if ( dir == NULL ) {
	dir = "/tmp";
    }

/*
 * allocate space for dir + '/' + pfx (up to 5 chars) + 6 trailing 'X's + 0 byte
 */
    if (( s = (char *)slapi_ch_malloc( strlen( dir ) + 14 )) == NULL ) {
	return( NULL );
    }

    strcpy( s, dir );
    strcat( s, "/" );
    if ( pfx != NULL ) {
	strcat( s, pfx );
    }
    strcat( s, "XXXXXX" );
    mktemp( s );

    if ( *s == '\0' ) {
	slapi_ch_free( (void**)&s );
    }

    return( s );
}
Beispiel #5
0
select_file_name (char * fname)
{
  next_file_num++;		/* advance counter */
  sprintf(fname, TEMP_FILE_NAME, TEMP_DIRECTORY, next_file_num);
  mktemp(fname);		/* make sure file name is unique */
  /* mktemp replaces the trailing XXXXXX with a unique string of characters */
}
Beispiel #6
0
void CRYPTO_thread_setup(void)
{
    int i;
    char filename[20];

    lock_cs = OPENSSL_malloc(CRYPTO_num_locks() * sizeof(usema_t *));
    if (!lock_cs) {
        /* Nothing we can do about this...void function! */
        return;
    }

    strcpy(filename, "/tmp/mttest.XXXXXX");
    mktemp(filename);

    usconfig(CONF_STHREADIOOFF);
    usconfig(CONF_STHREADMALLOCOFF);
    usconfig(CONF_INITUSERS, 100);
    usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);
    arena = usinit(filename);
    unlink(filename);

    for (i = 0; i < CRYPTO_num_locks(); i++) {
        lock_cs[i] = usnewsema(arena, 1);
    }

    CRYPTO_set_id_callback((unsigned long (*)())irix_thread_id);
    CRYPTO_set_locking_callback((void (*)())irix_locking_callback);
}
Beispiel #7
0
/* Replace all file names in a list with temporary files with the same
 * name extension as the original name. */
static void m2c_replace_temp_file_name(struct list_t *file_list)
{
	int index;

	char *name;
	char *name_ext;
	char new_name[MAX_STRING_SIZE];

	LIST_FOR_EACH(file_list, index)
	{
		/* Get old name and its extension */
		name = list_get(file_list, index);
		name_ext = rindex(name, '.');
		if (!name_ext || rindex(name_ext, '/'))
			name_ext = "";

		/* Create new file */
		strcpy(new_name, "/tmp/XXXXXX");
		mktemp(new_name);
		if (name_ext)
			strcat(new_name, name_ext);

		/* Replace it */
		free(name);
		list_set(file_list, index, xstrdup(new_name));
	}
Beispiel #8
0
int main(int argc, char **argv)
{
  char *temp;
  struct stat fileExists;
 
  if(argc < 2)
    temp = strcat(argv[0], "XXXXXX");
  else
    temp = strcat(argv[1], "XXXXXX");
     
  char * file = mktemp(temp);

  if(fopen(file, "w+") != NULL)
  {
    fprintf(stdout, "%s\n", file);
  }
  else 
  {
    perror("Error: ");
    return errno;
  }
  
  int result = stat(file, &fileExists);
  if(result == 0)
     fprintf(stdout, "File exists\n");
  else
     fprintf(stdout, "File does not exist\n");
 
  return 0;
}
Beispiel #9
0
/* check if directory is writable */
boolean
directory_is_writable (char *path)
{
	FILE *f;
	char *s;
	int fd;
#if defined(_WIN32)
	s = concat_strings(path, "\\ctm.XXXXXX");
	/* mingw doesn't have mkstemp */
	s = mktemp(s);
	f = fopen(s, "w");
#else
	s = concat_strings(path, "/ctm.XXXXXX");
	fd = mkstemp(s);
	if (fd == -1)
		return FALSE;
	f = fdopen(fd, "w");
#endif
	if (f == NULL) {
		return FALSE;
	} else {
		fclose (f);
		unlink(s);
		return TRUE;
	}
}
Beispiel #10
0
/* Convert BSDF (MGF) geometry to Radiance description */
static int
geomBSDF(const SDData *bsp)
{
	char	tmpfile[64];
	char	command[SDnameLn+64];
	int	fd;
					/* write MGF to temp file */
	fd = open(mktemp(strcpy(tmpfile,TEMPLATE)), O_WRONLY|O_CREAT|O_EXCL, 0600);
	if (fd < 0) {
		fprintf(stderr, "Cannot open temp file '%s'\n", tmpfile);
		return(0);
	}
	(void)write(fd, bsp->mgf, strlen(bsp->mgf));
	close(fd);
					/* set up command */
	if (do_instance) {
		sprintf(command, "mgf2rad %s | oconv -f - > %s.oct",
					tmpfile, bsp->name);
	} else {
		fflush(stdout);
		sprintf(command, "mgf2rad %s", tmpfile);
	}
	if (system(command)) {
		fprintf(stderr, "Error running: %s\n", command);
		return(0);
	}
	unlink(tmpfile);		/* remove temp file */
	if (do_instance) {		/* need to output instance? */
		printf("void instance %s_g\n", bsp->name);
		printf("1 %s.oct\n0\n0\n\n", bsp->name);
	}
	return(1);
}
Beispiel #11
0
/* Preparation.  */
void
do_prepare (int argc, char *argv[])
{
  size_t test_dir_len;

  test_dir_len = strlen (test_dir);

  /* Generate the circular symlinks.  */
  name1 = malloc (test_dir_len + sizeof ("/canonXXXXXX"));
  mempcpy (mempcpy (name1, test_dir, test_dir_len),
	   "/canonXXXXXX", sizeof ("/canonXXXXXX"));
  name2 = strdup (name1);

  add_temp_file (mktemp (name1));
  add_temp_file (mktemp (name2));
}
Beispiel #12
0
int main(int argc, string argv[])
{
  string prog, itags[MaxBodyFields];
  stream xstr;
  int nprof, nbody, nsamp;
  real *prof1, *prof2, rrange[2], tnow;
  bodyptr btab = NULL;

  initparam(argv, defv);
  layout_body(fields, Precision, NDIM);
  prog = mktemp((string) copxstr("/tmp/sm_XXXXXX", sizeof(char)));
  xstr = execmap(prog);
  get_history(xstr);
  nprof = getiparam("nprof");
  prof1 = (real *) allocate((2 + nprof) * sizeof(real));
  prof2 = (real *) allocate((2 + nprof) * sizeof(real));
  setrange(rrange, getparam("rrange"));
  nsamp = 0;
  while (get_snap(xstr, &btab, &nbody, &tnow, itags, FALSE)) {
    setprofile(prof1, prof2, nprof, rrange, btab, nbody);
    nsamp++;
  }
  if (unlink(prog) != 0)
    error("%s: can't unlink %s\n", getargv0(), prog);
  if (nsamp == 0)
    error("%s: no data in input\n", getargv0());
  listdensity(prof1, prof2, nprof, rrange, nsamp);
  return (0);
}
Beispiel #13
0
static inline int
gg_mkstemp(char *path)
{
	mode_t old_umask, file_mask;
	int ret;

	file_mask = S_IRWXO | S_IRWXG;
	old_umask = umask(file_mask);
#ifdef HAVE_MKSTEMP
	ret = mkstemp(path);
#else
#ifdef _WIN32
	if (_mktemp_s(path, strlen(path) + 1) != 0)
#else
	/* coverity[secure_temp : FALSE]
	 *
	 * mktemp may be unsafe, because it creates files with predictable
	 * names, but it's not a real problem for automatic tests.
	 */
	if (strcmp(mktemp(path), "") == 0)
#endif
		ret = -1;
	else
		ret = open(path, O_EXCL | O_RDWR | O_CREAT, file_mask);
#endif
	umask(old_umask);

	return ret;
}
Beispiel #14
0
int main(int argc, string argv[])
{
  string prog, itags[MaxBodyFields], otags[MaxBodyFields];
  stream xstr, ostr;
  bodyptr btab = NULL;
  int nbody;
  real tnow;

  initparam(argv, defv);
  exprs[0] = getparam("weight");
  prog = mktemp((string) copxstr("/tmp/sm_XXXXXX", sizeof(char)));
  buildmap(prog, names, exprs, types, NULL, Precision, NDIM, TRUE);
  xstr = execmap(prog);
  if (get_tag_ok(xstr, "History"))
    skip_item(xstr);
  get_history(xstr);
  ostr = stropen(getparam("out"), "w");
  put_history(ostr);
  new_field(&WeightField, RealType, "Weight");
  new_field(&WeightField + 1, NULL, NULL);
  while (get_snap(xstr, &btab, &nbody, &tnow, itags, TRUE)) {
    snaprect(btab, nbody);
    del_tag(otags, itags, "Weight");
    put_snap(ostr, &btab, &nbody, &tnow, otags);
  }
  strclose(ostr);
  if (unlink(prog) != 0)
    error("%s: can't unlink %s\n", getargv0(), prog);
  return (0);
}
Beispiel #15
0
	/**
	 * Creates a new C source file and adds a standard header. If filename is
	 * empty, a unique random name is produced and used.
	 */
	void create_src_file(std::string& filename, std::ofstream& ofs)
	{
		if (filename.empty()) {
			// fill filename with unique random word
			const char* filename_pattern = "./GiNaCXXXXXX";
			char* new_filename = new char[strlen(filename_pattern)+1];
			strcpy(new_filename, filename_pattern);
			if (!mktemp(new_filename)) {
				delete[] new_filename;
				throw std::runtime_error("mktemp failed");
			}
			filename = std::string(new_filename);
			ofs.open(new_filename, std::ios::out);
			delete[] new_filename;
		} else {
			// use parameter as filename
			ofs.open(filename.c_str(), std::ios::out);
		}
		
		if (!ofs) {
			throw std::runtime_error("could not create source code file for compilation");
		}

		ofs << "#include <stddef.h> " << std::endl;
		ofs << "#include <stdlib.h> " << std::endl;
		ofs << "#include <math.h> " << std::endl;
		ofs << std::endl;
	}
Beispiel #16
0
/* create an empty temporary file and return its name */
static char *scratch_file(void) {
    FILE *f;
    char *temp;
    char *path = malloc(256);
    if (path == NULL)
	return NULL;
    if ( (temp = getenv("TEMP")) != NULL )
	strcpy(path, temp);
    else if ( (temp = getenv("TMP")) != NULL )
	strcpy(path, temp);
    else
	strcpy(path, "c:\\");

    /* Prevent X's in path from being converted by mktemp. */
    for ( temp = path; *temp; temp++ ) {
	    *temp = (char)tolower(*temp);
	    if (*temp == '/')
		*temp = '\\';
    }
    if ( strlen(path) && (path[strlen(path)-1] != '\\') )
	    strcat(path, "\\");

    strcat(path, "ptXXXXXX");
    mktemp(path);
    f = fopen(path, "w");
    if (f==NULL) {perror(cmd); exit(1);}
    fclose(f);
    return path;
}
Beispiel #17
0
//create temp file
void RCommitLog::createTempLog() {

    std::string tempdir;

#ifdef _WIN32
    DWORD tmplen = GetTempPath(0, 0);

    if(tmplen == 0) return;

    std::vector<TCHAR> temp(tmplen+1);

    tmplen = GetTempPath(static_cast<DWORD>(temp.size()), &temp[0]);

    if(tmplen == 0 || tmplen >= temp.size()) return;

    tempdir = std::string(temp.begin(), temp.begin() + static_cast<std::size_t>(tmplen));
    tempdir += "\\";
#else
    tempdir = "/tmp/";
#endif

    char tmplate[1024];
    snprintf(tmplate, 1024, "%sgource-XXXXXX", tempdir.c_str());

#ifdef _WIN32
    if(mktemp(tmplate) < 0) return;
#else
    if(mkstemp(tmplate) < 0) return;
#endif

    temp_file = std::string(tmplate);
}
static char *
unique_filename(const char *path, const char *prefix, int *pFd)
#endif
{
#ifndef HAVE_MKSTEMP
#ifndef X_NOT_POSIX
    return ((char *) tempnam (path, prefix));
#else
    char tempFile[PATH_MAX];
    char *tmp;

    snprintf (tempFile, sizeof(tempFile), "%s/%sXXXXXX", path, prefix);
    tmp = (char *) mktemp (tempFile);
    if (tmp)
    {
	return strdup(tmp);
    }
    else
	return (NULL);
#endif
#else 
    char tempFile[PATH_MAX];
    char *ptr;

    snprintf (tempFile, sizeof(tempFile), "%s/%sXXXXXX", path, prefix);
    ptr = strdup(tempFile);
    if (ptr != NULL) 
    {
	*pFd =  mkstemp(ptr);
    }
    return ptr;
#endif
}
Beispiel #19
0
static int
do_test (int argc, char *argv[])
{
  int retval;

  if (mktemp (tmpname) == NULL)
    {
      perror ("mktemp");
      return 1;
    }

  /* Try to generate a FIFO.  */
  if (mknod (tmpname, 0600 | S_IFIFO, 0) < 0)
    {
      perror ("mknod");
      /* We cannot make this an error.  */
      return 0;
    }

  retval = real_test ();

  remove (tmpname);

  return retval;
}
Beispiel #20
0
/**
 * librdf_files_temporary_file_name:
 * 
 * Create a temporary file name.
 * 
 * @deprecated: Do not use this, it is unsafe.
 *
 * Return value: a new filename or NULL on failure.
 **/
char *
librdf_files_temporary_file_name(void) 
{
#if defined(HAVE_MKSTEMP) || defined(HAVE_MKTEMP)
  const char *tmp_dir;
  size_t length;
  char *name;
  static const char * const file_template="librdf_tmp_XXXXXX"; /* FIXME */
#ifdef HAVE_MKSTEMP
  int fd;
#endif

  /* FIXME: unix dependencies */
  tmp_dir=getenv("TMPDIR");
  if(!tmp_dir)
    tmp_dir="/tmp";

  length=strlen(tmp_dir) + strlen(file_template) + 2; /* 2: / sep and \/0 */
  
  name = LIBRDF_MALLOC(char*, length);
  if(!name)
    return NULL;

  /* FIXME: unix dependency - file/dir separator */
  sprintf(name, "%s/%s", tmp_dir, file_template);
  
#ifdef HAVE_MKSTEMP
  /* Proritise mkstemp() since GNU libc says: Never use mktemp(). */
  fd=mkstemp(name);
  if(fd<0) {
    LIBRDF_FREE(char*, name);
    return NULL;
  }
  close(fd);
  unlink(name);

  return name;  
#else
  return mktemp(name);
#endif

#else
#ifdef HAVE_TMPNAM
  /* GNU libc says: Never use this function. Use mkstemp(3) instead. */
  char *name;
  char *new_name;

  name=tmpnam(NULL); /* NULL ensures statically allocated */
  new_name = LIBRDF_MALLOC(char*, strlen(name) + 1);
  if(!new_name)
    return NULL;
  strcpy(new_name, name);

  return name;
#else /* not tmpnam(), mkstemp() or mktemp() */
HELP
#endif
#endif
}
Beispiel #21
0
startnlfile()
{
	nlsize = 0;
	(void) mktemp(symname);
	(void) mktemp(strname);
	(void) mktemp(filesname);
	(void) mktemp(linesname);
	symfp = fopen(symname, "w");
	strfp = fopen(strname, "w");
	filesfp = fopen(filesname, "w");
	linesfp = fopen(linesname, "w");
	if (symfp==NULL || strfp==NULL || filesfp==NULL || linesfp==NULL) {
		fprintf(stderr, "can't create /tmp/obj");
		pexit(NOSTART);
	}
	newfile(filename, 1);
}
Beispiel #22
0
char*
maketmp(void)
{
	static char temp[] = "/tmp/mkargXXXXXX";

	mktemp(temp);
	return temp;
}
int mkstemp(char *tmpl)
{
   int ret=-1;

mktemp(tmpl); ret=open(tmpl,O_RDWR|O_BINARY|O_CREAT|O_EXCL|_O_SHORT_LIVED, _S_IREAD|_S_IWRITE);

   return ret;
}
Beispiel #24
0
int main()
{
    tmpname = mktemp("T:flockXXXXXX");
    int fd = open(tmpname, O_CREAT);
    TEST((fd != -1));

    TEST((flock(fd, LOCK_SH|LOCK_NB) == 0));
    TEST((flock(fd, LOCK_UN) == 0));

    TEST((flock(fd, LOCK_EX|LOCK_NB) == 0));
    TEST((flock(fd, LOCK_UN) == 0));

    TEST((flock(fd, LOCK_SH) == 0));
    TEST((flock(fd, LOCK_UN) == 0));

    TEST((flock(fd, LOCK_EX) == 0));
    TEST((flock(fd, LOCK_UN) == 0));

    close(fd);

    /* Create NPROCS processes increasing counter ITERATIONS times in an ugly 
       way */
    int counter = 0;
    struct Process *procs[NPROCS];
    ULONG ids[NPROCS];
    struct TagItem tags[] =
    {
	{ NP_Entry,         (IPTR) entry     },
        { NP_Name,          (IPTR) "flocker" },
        { NP_Output,        (IPTR) Output()  },
        { NP_CloseOutput,   (IPTR) FALSE     },
        { NP_UserData,      (IPTR) &counter  },
        { NP_NotifyOnDeath, (IPTR) TRUE      },
        { TAG_DONE,         0                }
    };

    int i;
    InitSemaphore(&sem);
    for(i = 0; i < NPROCS; i++)
    {
	procs[i] = CreateNewProc(tags);
	TEST((procs[i]));
	ids[i] = GetETask(procs[i])->et_UniqueID;
	Signal((struct Task *)procs[i], SIGBREAKF_CTRL_C);
    }
    
    for(i = 0; i < NPROCS; i++)
    {
	ChildWait(ids[i]);
	ChildFree(ids[i]);
    }
    putchar('\n');
    
    TEST((counter == NPROCS * ITERATIONS));
    
    cleanup();
    return OK;
}
int main(int argc, char **argv) {
  FILE *fp;
  char *tmp_fname;
  char tmp_msg[PATH_MAX];
  int rc=-1;

  strncpy(fname, "/tmp/std_config_node_text_XXXXX", sizeof(fname));
  fname[sizeof(fname)-1] = 0;

  tmp_fname = mktemp(fname);
  if ((tmp_fname == NULL) || (strlen(tmp_fname) == 0))
  {
      perror("Unable to create temporary xml file: ");
      return -1;
  }

  fp=fopen(tmp_fname,"w+");

  if (fp == NULL)
  {
      perror("Unable to create a temporary file: ");
      return -1;
  }
  rc=generate_xmlfile(fp);

  if (rc != 0)
  {
      if( fclose (fp) != 0)
      {
          snprintf(tmp_msg,PATH_MAX,"Unable to close the temporary file created:%s",tmp_fname);
          perror(tmp_msg);
      }

      rc = unlink(tmp_fname);
      if(rc != 0)
      {
          snprintf(tmp_msg,PATH_MAX,"Unable to delete the temporary file created:%s",tmp_fname);
          perror(tmp_msg);
      }
      return -1;
  }


  ::testing::InitGoogleTest(&argc, argv);
  rc=RUN_ALL_TESTS();
  if( fclose (fp) != 0)
  {
      snprintf(tmp_msg,PATH_MAX,"Unable to close the temporary file created:%s",tmp_fname);
      perror(tmp_msg);
  }
  rc = unlink(tmp_fname);
  if(rc != 0)
  {
        snprintf(tmp_msg,PATH_MAX,"Unable to delete the temporary file created:%s",tmp_fname);
      perror(tmp_msg);
  }
  return rc;
}
Beispiel #26
0
int mktemp_main(int argc UNUSED_PARAM, char **argv)
{
	const char *path;
	char *chp;
	unsigned opts;
	enum {
		OPT_d = 1 << 0,
		OPT_q = 1 << 1,
		OPT_t = 1 << 2,
		OPT_p = 1 << 3,
		OPT_u = 1 << 4,
	};

	path = getenv("TMPDIR");
	if (!path || path[0] == '\0')
		path = "/tmp";

	opt_complementary = "?1"; /* 1 argument max */
	opts = getopt32(argv, "dqtp:u", &path);

	chp = argv[optind];
	if (!chp) {
		/* GNU coreutils 8.4:
		 * bare "mktemp" -> "mktemp -t tmp.XXXXXX"
		 */
		chp = xstrdup("tmp.XXXXXX");
		opts |= OPT_t;
	}
#if 0
	/* Don't allow directory separator in template */
	if ((opts & OPT_t) && bb_basename(chp) != chp) {
		errno = EINVAL;
		goto error;
	}
#endif
	if (opts & (OPT_t|OPT_p))
		chp = concat_path_file(path, chp);

	if (opts & OPT_u) {
		chp = mktemp(chp);
		if (chp[0] == '\0')
			goto error;
	} else if (opts & OPT_d) {
		if (mkdtemp(chp) == NULL)
			goto error;
	} else {
		if (mkstemp(chp) < 0)
			goto error;
	}
	puts(chp);
	return EXIT_SUCCESS;
 error:
	if (opts & OPT_q)
		return EXIT_FAILURE;
	/* don't use chp as it gets mangled in case of error */
	bb_perror_nomsg_and_die();
}
Beispiel #27
0
int download_file(const char * dst, const char * src, const char * md5)
{

    if (!(*src) || !(*dst))
    {
        return NODE_ERR_REQ_DATA;
    }


    char temp_file[PATH_MAX] = {0};
    snprintf(temp_file, PATH_MAX, "%sXXXXXX", dst);
    mktemp(temp_file);

    g_http_transfer.download_file(src, temp_file);

    DEBUG_LOG("downloaded %s to %s", src, dst);

    if (NULL != md5)
    {
        char temp_md5[MD5_LEN + 1] = {0};
        if (0 != get_file_md5(temp_file, temp_md5))
        {
            ERROR_LOG("download file %s to %s failed", src, dst);
            return NODE_ERR_DOWNLOAD_FAIL;
        }

        if (0 != strncmp(md5, temp_md5, MD5_LEN))
        {
            ERROR_LOG("download file %s to %s, \noriginal md5: %s, actual md5: %s, mismatch", 
                    src, dst, md5, temp_md5);
            remove(temp_file);
            return NODE_ERR_MD5_MISMATCH;
        }


    }

    int ret = rename(temp_file, dst);
    if (0 != ret)
    {
        remove(temp_file);
        if (EBUSY == errno)
        {
            return NODE_ERR_FILE_BUSY;
        }
        else if (EACCES == errno)
        {
            return NODE_ERR_ACCESS;
        }
        else
        {
            return NODE_ERR_UNKNOWN;
        }
    }

    return 0;
}
Beispiel #28
0
int bx_mkstemp(char *tpl)
{
  mktemp(tpl);
  return ::open(tpl, O_RDWR | O_CREAT | O_TRUNC
#  ifdef O_BINARY
            | O_BINARY
#  endif
              , S_IWUSR | S_IRUSR | S_IRGRP | S_IWGRP);
}
Beispiel #29
0
void spool(char *path)
/* Place a file into the spool directory, either by copying it, or by leaving
 * a reference.
 */
{
	char *file;
	int j, u;

	mktemp(jobX);
	file= mktemp(tmpX);

	if (path[0] == '/') {
		int f;

		if ((f= open(path, O_RDONLY)) >= 0) {
			close(f);
			file= path;
		}
	}
	if (file != path) {
		int c;
		FILE *t;

		if ((t= fopen(tmpX, "w")) == nil) spoolerr(tmpX);

		while ((c= getchar()) != EOF && putc(c, t) != EOF) {}

		if (ferror(stdin)) spoolerr(path);

		if (ferror(t) || fclose(t) == EOF) spoolerr(tmpX);

		fclose(stdin);
	}

	if ((j= open(jobX, O_WRONLY|O_CREAT|O_EXCL, 0000)) < 0) spoolerr(jobX);

	u= getuid();
	if (write(j, file, strlen(file)+1) < 0
		|| write(j, &u, sizeof(u)) < 0
		|| write(j, path, strlen(path)+1) < 0
		|| close(j) < 0
		|| chmod(jobX, 0600) < 0
	) spoolerr(jobX);
}
Beispiel #30
0
int main()
{
	char *path1;
	char *path2;
	char *cwd;
	int status;

	path1 = mkdtemp(strdup(TEMPLATE));
	if (path1 == NULL)
		exit(EXIT_FAILURE);

	status = chdir(path1);
	if (status < 0)
		exit(EXIT_FAILURE);

	status = mkdir(COOKIE1, 0777);
	if (status < 0)
		exit(EXIT_FAILURE);

	status = chdir(COOKIE1);
	if (status < 0)
		exit(EXIT_FAILURE);

	status = creat(COOKIE2, O_RDWR);
	if (status < 0)
		exit(EXIT_FAILURE);
	close(status);

	path2 = mktemp(strdup(TEMPLATE));
	status = rename(path1, path2);
	if (status < 0)
		exit(EXIT_FAILURE);

	status = access(COOKIE2, F_OK);
	if (status < 0)
		exit(EXIT_FAILURE);

	cwd = get_current_dir_name();
	if (cwd == NULL || memcmp(cwd, path2, strlen(path2)) != 0)
		exit(EXIT_FAILURE);

	status = unlink(COOKIE2);
	if (status < 0)
		exit(EXIT_FAILURE);

	status = rmdir(cwd);
	if (status < 0)
		exit(EXIT_FAILURE);

	/* TODO:
	if (get_current_dir_name() != NULL || errno != ENOENT)
		exit(EXIT_FAILURE);
	*/

	exit(EXIT_SUCCESS);
}