static int writeread(char *origfilename, char *newfilename) {
char wbuf[write_size];
int fd;
for (int idx = 0; idx < write_size; idx++) {
wbuf[idx] = randomchar();
}
v_printf("write: ");
int bytes_written;
fd = open(origfilename, O_RDWR | O_CREAT, 0640);
if (fd < 0) {
v_printf("OPEN ERROR: open failed on %s : %d %s\n", origfilename, errno, strerror(errno));
return -1;
}
bytes_written = write(fd, wbuf, write_size);
if (bytes_written != write_size) {
v_printf("WRITE ERROR: bytes_written = %d, write_size = %d\n", bytes_written, write_size);
return -3;
}
else {
v_printf("Write Success: %s\n", origfilename);
}
sleep(10);
if (rename(origfilename, newfilename) != 0) {
v_printf("RENAME ERROR: old: %s; new: %s; errno: %d; err: %s\n", origfilename, newfilename, errno, strerror(errno));
return -4;
}
close(fd);
return 0;
}
int main()
{
srand(time(NULL)); // seed random function
int i;
Tnode* tree = add_tnode(tree,randomchar(length_string)); // initialize a tree
for(i=0; i<num_nodes; i++) //insert random elements
insert(tree, randomchar(length_string) );
printTree(tree); // print the tree once
printf("--------free from now on-----------\n");
freeTree(tree); // go in the right order and free the tree
// printTree(tree); if this line added, it shows that the free function works
return 0;
}
static int writeread(char *basename, int results[], const int num_files, char failedfiles[FHFMAX][FHFSIZE]) {
char wbuf[num_files][write_iters][one_write_size];
char filename[PATH_MAX];
int fd[num_files];
int cdx = 0;
for (int idx = 0; idx < num_files; idx++) {
for (int jdx = 0; jdx < write_iters; jdx++) {
for (int kdx = 0; kdx < one_write_size; kdx++) {
wbuf[idx][jdx][kdx] = randomchar();
}
}
}
vv_printf("write: ");
for (int idx = 0; idx < num_files; idx++) {
int bytes_written;
sprintf(filename, "%s-%d", basename, idx);
fd[idx] = open(filename, O_RDWR | O_CREAT, 0640);
if (fd[idx] < 0) {
++results[OpenErrors];
v_printf("OPEN ERROR: open failed on %s : %d %s\n", filename, errno, strerror(errno));
}
else {
if (!verbose) printf(".");
printf("Shut valhalla down now! (systemctl stop nginx_valhalla.service\n");
sleep(23);
for (int jdx = 0; jdx < write_iters; jdx++) {
bytes_written = write(fd[idx], wbuf[idx][jdx], one_write_size);
if (bytes_written == -1) {
++results[WriteErrors];
v_printf("WRITE ERROR: %s: bytes_written = -1, errno = %d (%s)\n", filename, errno, strerror(errno));
strcpy(failedfiles[cdx++], filename);
}
else if (bytes_written != one_write_size) {
++results[WriteErrors];
v_printf("WRITE ERROR: %s: bytes_written = %d, one_write_size = %d\n", filename, bytes_written, one_write_size);
}
else {
++results[Writes];
vv_printf("Write Success: %s\n", filename);
}
printf("Sleep between writes to better view journalctl output\n");
sleep(2);
}
close(fd[idx]);
}
}
v_printf("\n");
return 0;
}
/**
* Create a new bus
*
* @param file The pathname of the bus, `NULL` to create a random one
* @param flags `BUS_EXCL` (if `file` is not `NULL`) to fail if the file
* already exists, otherwise if the file exists, nothing
* will happen;
* `BUS_INTR` to fail if interrupted
* @param out_file Output parameter for the pathname of the bus
* @return 0 on success, -1 on error
*/
int
bus_create(const char *file, int flags, char **out_file)
{
int fd = -1, saved_errno;
bus_t bus;
char buf[1 + 2 * (3 * sizeof(ssize_t) + 2)];
size_t ptr, len;
ssize_t wrote;
char *genfile = NULL;
const char *env;
if (out_file)
*out_file = NULL;
bus.sem_id = -1;
bus.key_sem = -1;
bus.key_shm = -1;
bus.message = NULL;
bus.first_poll = 0;
srand((unsigned int)time(NULL) + (unsigned int)rand());
if (file) {
fd = open(file, O_WRONLY | O_CREAT | O_EXCL, DEFAULT_MODE);
if (fd == -1) {
if ((errno != EEXIST) || (flags & BUS_EXCL))
return -1;
goto done;
}
} else {
env = getenv("XDG_RUNTIME_DIR");
if (!env || !*env)
env = "/run";
genfile = malloc((strlen(env) + 6 + 7 + 30) * sizeof(char));
if (!genfile)
goto fail;
if (out_file)
*out_file = genfile;
sprintf(genfile, "%s/bus", env);
t(mkdirs(genfile, 0755));
sprintf(genfile, "%s/bus/random.", env);
len = strlen(genfile);
genfile[len + 30] = '\0';
retry:
for (ptr = 0; ptr < 30; ptr++)
genfile[len + ptr] = randomchar();
fd = open(genfile, O_WRONLY | O_CREAT | O_EXCL, DEFAULT_MODE);
if (fd == -1) {
if (errno == EEXIST)
goto retry;
return -1;
}
}
t(create_semaphores(&bus));
t(create_shared_memory(&bus));
sprintf(buf, "%zi\n%zi\n", (ssize_t)(bus.key_sem), (ssize_t)(bus.key_shm));
for (len = strlen(buf), ptr = 0; ptr < len;) {
wrote = write(fd, buf + ptr, len - ptr);
if (wrote < 0) {
if ((errno != EINTR) || (flags & BUS_INTR))
goto fail;
} else {
ptr += (size_t)wrote;
}
}
close(fd);
done:
if (out_file && !*out_file) {
len = strlen(file) + 1;
*out_file = malloc(len * sizeof(char));
memcpy(*out_file, file, len * sizeof(char));
} else if (!out_file) {
free(genfile);
}
return 0;
fail:
saved_errno = errno;
if (bus.key_sem)
remove_semaphores(&bus);
if (bus.key_shm)
remove_shared_memory(&bus);
if (fd == -1)
close(fd);
if (out_file)
*out_file = NULL;
free(genfile);
unlink(file);
errno = saved_errno;
return -1;
}
