1525 lines
40 KiB
C
Executable File
1525 lines
40 KiB
C
Executable File
/*
|
|
SlideScript - minimalistic top-down scripting language.
|
|
(C) Copyright 2014-2021 Chris Dorman - some rights reserved (GPLv2)
|
|
|
|
View README file supplied with this software for more details
|
|
*/
|
|
|
|
#include "inc/deps.h"
|
|
#include "inc/lexer.h"
|
|
#include "inc/util.h"
|
|
#include "inc/vars.h"
|
|
#include "inc/enc.h"
|
|
#include "inc/math.h"
|
|
#include "inc/md5.h"
|
|
#include "inc/network.h"
|
|
#include "inc/search.h"
|
|
#include "inc/inset.h"
|
|
// For slidescript compression algorithm
|
|
#include "inc/tar.h"
|
|
#include "inc/compression.h"
|
|
|
|
char *process_line(char *line)
|
|
{
|
|
char *tok_srch;
|
|
|
|
//printf("%s", &line[strlen(line)-2]);
|
|
|
|
static char concatbuf[MAX_CONCAT_BUF+1];
|
|
static char filebuf[MAX_READFILE_LEN+1];
|
|
static char retbuf[MAX_STRING_BUFSIZE];
|
|
static char compbuf[MAX_STRING_BUFSIZE];
|
|
static char loopbuf[MAX_STRING_BUFSIZE];
|
|
static char countbuf[MAX_STRING_BUFSIZE];
|
|
|
|
// Make sure static buffers are empty before initialize
|
|
// Write with zeros
|
|
bzero(filebuf, MAX_READFILE_LEN);
|
|
bzero(concatbuf, MAX_CONCAT_BUF);
|
|
bzero(retbuf, MAX_STRING_LEN);
|
|
|
|
tok_srch = strtok(line, "=\" ;");
|
|
|
|
/* reuse function */
|
|
/*else if(strncmp("temp",tok_srch,4) == 0)
|
|
{
|
|
tok_srch = strtok(NULL, " ");
|
|
}*/
|
|
|
|
/* if line starts with a comment, skip */
|
|
if(strncmp("#",tok_srch,1) == 0)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Check for main calls from user in interactive
|
|
else if(strncmp("exit", tok_srch, 4) == 0)
|
|
syn_error("ss:exit called");
|
|
|
|
else if(strncmp("version", tok_srch, 7) == 0)
|
|
printf("ss:version: %s, type 'help' for function list\n", VERSION);
|
|
|
|
else if(strncmp("help", tok_srch, 4) == 0)
|
|
printf("ss:help:\n%s", FUNCTION_HELP);
|
|
|
|
|
|
// Lets add if and loop statements, make this
|
|
// Somewhat usable as a language in other instances
|
|
|
|
// Loop
|
|
else if(strncmp("loop:", tok_srch, 4) == 0)
|
|
{
|
|
int loop_count, ii;
|
|
char *proc_return;
|
|
|
|
if(loopbuf != NULL || countbuf != NULL)
|
|
{
|
|
bzero(loopbuf, MAX_STRING_LEN);
|
|
bzero(countbuf, MAX_STRING_LEN);
|
|
}
|
|
|
|
*loopbuf = '\0';
|
|
// We have an if statement
|
|
tok_srch = strtok(NULL, ";");
|
|
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:loop statement requires arguments");
|
|
return NULL;
|
|
}
|
|
|
|
strcat(countbuf, parse_vars(tok_srch));
|
|
loop_count = atoi(countbuf);
|
|
|
|
tok_srch = strtok(NULL, ";");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:loop syntax error, missing last argument?");
|
|
return NULL;
|
|
}
|
|
|
|
strcat(loopbuf, parse_vars(tok_srch));
|
|
|
|
for(ii = 0; ii < loop_count; ii++)
|
|
{
|
|
proc_return = process_line(parse_vars(loopbuf));
|
|
printf("%s\n", proc_return);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// IF statement
|
|
else if(strncmp("comp:", tok_srch, 5) == 0)
|
|
{
|
|
if(compbuf != NULL)
|
|
{
|
|
bzero(compbuf, MAX_STRING_LEN);
|
|
}
|
|
|
|
// We have an if statement
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:if statement requires arguments");
|
|
return NULL;
|
|
}
|
|
|
|
// Check if there's anything after the first quote
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:if syntax error, missing first argument?");
|
|
return NULL;
|
|
}
|
|
|
|
// Make sure the end quote exists
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:if syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strlen(tok_srch) < MAX_STRING_LEN)
|
|
{
|
|
strcpy(compbuf, parse_vars(tok_srch));
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:if, return exceeds compare buffer");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:if statement requires two compared arguments");
|
|
return NULL;
|
|
}
|
|
|
|
// Check if there's anything after the first quote
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:if syntax error, missing second argument?");
|
|
return NULL;
|
|
}
|
|
|
|
// Make sure the end quote exists
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:if syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(atoi(compbuf) == atoi(parse_vars(tok_srch)))
|
|
{
|
|
return "true";
|
|
}
|
|
else
|
|
{
|
|
return "false";
|
|
}
|
|
}
|
|
|
|
// Change directory
|
|
else if(strncmp("backdir", tok_srch, 7) == 0)
|
|
{
|
|
int chdir_return = chdir("..");
|
|
if(chdir_return < 0)
|
|
{
|
|
syn_warn("ss:warn:backdir, failed to move directory location");
|
|
}
|
|
}
|
|
|
|
// Move files using rename()
|
|
else if(strncmp("move",tok_srch,4) == 0 || strncmp("mv", tok_srch, 2) == 0)
|
|
{
|
|
char orig_fn[MAX_STRING_BUFSIZE]; // Should never be more than 6 characters
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:move syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:move syntax error, missing filename?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strlen(parse_vars(tok_srch)) < MAX_STRING_LEN)
|
|
{
|
|
strcpy(orig_fn, parse_vars(tok_srch));
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:move syntax error, missing first filename?");
|
|
return NULL;
|
|
}
|
|
|
|
/* strtok to the content that will be written to file */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:move syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:move syntax error, missing second filename?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:move syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
int rename_return = rename(orig_fn, parse_vars(tok_srch));
|
|
if(rename_return < 0)
|
|
{
|
|
syn_warn("ss:warn:move, failed to move file");
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// Show current directory.
|
|
else if(strncmp("showpath", tok_srch, 8) == 0 || strncmp("pwd", tok_srch, 3) == 0)
|
|
{
|
|
// Get current directory, if it errors, return NULL
|
|
if (getcwd(retbuf, sizeof(retbuf)) == NULL) {
|
|
return NULL;
|
|
}
|
|
// All good, return path
|
|
return retbuf;
|
|
}
|
|
|
|
// Change directory
|
|
else if(strncmp("chdir", tok_srch, 5) == 0 || strncmp("cd", tok_srch, 2) == 0)
|
|
{
|
|
char *dirname;
|
|
int chdir_return;
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:chdir syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:chdir syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
dirname = parse_vars(tok_srch);
|
|
|
|
chdir_return = chdir(dirname);
|
|
|
|
if(chdir_return < 0)
|
|
{
|
|
syn_warn("ss:warn:chdir, error changing directory");
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
else if(strncmp("showdir", tok_srch, 7) == 0 || strncmp("ls", tok_srch, 2) == 0)
|
|
{
|
|
char *dirname;
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
dirname = ".";
|
|
}
|
|
|
|
if(strtok(NULL, "\"")==NULL && dirname == NULL)
|
|
{
|
|
syn_warn("ss:warn:showdir syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(dirname == NULL)
|
|
dirname = parse_vars(tok_srch);
|
|
|
|
sprintf(retbuf, "%s\n", "ss:showdir:");
|
|
|
|
struct dirent **files;
|
|
int nn;
|
|
|
|
nn = scandir (dirname, &files, NULL, alphasort);
|
|
|
|
if (nn < 0)
|
|
{
|
|
syn_warn("ss:warn:showdir, failed to open directory");
|
|
return NULL;
|
|
}
|
|
|
|
for (int ii = 0; ii < nn; ii++)
|
|
{
|
|
struct dirent *ent = files [ii];
|
|
if((strlen(retbuf) + strlen(ent->d_name) + 1) < MAX_STRING_LEN)
|
|
{
|
|
strcat(retbuf, ent->d_name);
|
|
strcat(retbuf, "\n");
|
|
}
|
|
}
|
|
|
|
for (int ii = 0; ii < nn; ii++) { free (files [ii]); }
|
|
free (files);
|
|
|
|
return retbuf;
|
|
}
|
|
|
|
|
|
/* COMPRESSION AND DECOMPRESSION */
|
|
else if(strncmp("decompress",tok_srch,10) == 0)
|
|
{
|
|
char *filename;
|
|
struct tar_t *archive = (void *)0;
|
|
int fd;
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:decompress syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"")==NULL)
|
|
{
|
|
syn_warn("ss:warn:decompress syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
filename = parse_vars(tok_srch);
|
|
|
|
FILE *in;
|
|
|
|
char origsize[128];
|
|
char filedecout[MAX_FILENAME_LEN+5];
|
|
|
|
in = fopen(filename, "rb");
|
|
if(in == NULL)
|
|
{
|
|
syn_warn("ss:warn:compress, failed to open tar for compression");
|
|
return NULL;
|
|
}
|
|
|
|
sprintf(filedecout, "uncompressed.tar");
|
|
|
|
sprintf(origsize, "%ld", fsize(in));
|
|
|
|
uint32_t deco_return = ss_decompress(filename, filedecout);
|
|
|
|
sprintf(retbuf, "ss: %s: decompressed: %s -> %u", filename, origsize, deco_return);
|
|
|
|
fclose(in);
|
|
|
|
// open existing file
|
|
if ((fd = open(filedecout, O_RDWR)) < 0) {
|
|
syn_warn("ss:warn:decompress, failed to tar open archive");
|
|
return NULL;
|
|
}
|
|
|
|
// read in data
|
|
if (tar_read(fd, &archive, '1') < 0) {
|
|
close(fd);
|
|
syn_warn("ss:warn:decompress, failed to read archive");
|
|
return NULL;
|
|
}
|
|
|
|
// perform operation
|
|
if(tar_extract(fd, archive, 0, NULL, '1') < 0) { // extract entries
|
|
syn_warn("ss:warn:decompress, error occured");
|
|
return NULL;
|
|
}
|
|
|
|
usleep(50);
|
|
|
|
if(archive != (void *)0)
|
|
{
|
|
tar_free(archive);
|
|
archive = (void *)0;
|
|
}
|
|
|
|
close(fd); // don't bother checking for fd < 0
|
|
|
|
remove(filedecout);
|
|
|
|
return retbuf;
|
|
|
|
}
|
|
|
|
/* Compression function of tar */
|
|
else if(strncmp("compress",tok_srch,8) == 0)
|
|
{
|
|
char filename[MAX_FILENAME_LEN+1]; // Files to be added into the archive
|
|
char comp_size[128];
|
|
struct tar_t *archive = (void *)0;
|
|
int fd;
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:compress syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:compress syntax error, missing archive name...");
|
|
return NULL;
|
|
}
|
|
|
|
// Save tarball filename
|
|
if(strlen(parse_vars(tok_srch)) < MAX_FILENAME_LEN)
|
|
{
|
|
sprintf(filename, "%s", parse_vars(tok_srch));
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:compress, filename too long!");
|
|
return NULL;
|
|
}
|
|
|
|
if ((fd = open(filename, O_WRONLY | O_TRUNC | O_CREAT, S_IRUSR | S_IWUSR)) == -1){
|
|
syn_warn("ss:warn:compress, failed to open new archive");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:compress syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:compress syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:compress, missing file path (what are we gonna compress?)");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"")==NULL)
|
|
{
|
|
syn_warn("ss:warn:compress syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
int argc = 0;
|
|
char *argv[MAX_FILES];
|
|
|
|
char *p2 = strtok(tok_srch, " ");
|
|
while (p2 && argc < MAX_FILES-1)
|
|
{
|
|
argv[argc++] = p2;
|
|
p2 = strtok(NULL, " ");
|
|
}
|
|
|
|
argv[argc] = 0;
|
|
|
|
const char **tarin = (const char **) &argv[0];
|
|
|
|
if (tar_write(fd, &archive, argc, tarin, '1') < 0) {
|
|
syn_warn("ss:warn:compress, failed to create tar archive");
|
|
return NULL;
|
|
}
|
|
|
|
if(archive != (void *)0)
|
|
{
|
|
tar_free(archive);
|
|
archive = (void *)0;
|
|
}
|
|
close(fd); // don't bother checking for fd < 0
|
|
|
|
FILE *in;
|
|
|
|
char origsize[128];
|
|
char file_comp[MAX_FILENAME_LEN+9];
|
|
char filedecout[MAX_FILENAME_LEN+10];
|
|
|
|
in = fopen(filename, "rb");
|
|
if(in == NULL)
|
|
{
|
|
syn_warn("ss:warn:compress, failed to open tar for compression");
|
|
return NULL;
|
|
}
|
|
|
|
sprintf(file_comp, "%s.tar.ss", filename);
|
|
sprintf(filedecout, "%s.tar.1", filename);
|
|
|
|
sprintf(origsize, "%ld", fsize(in));
|
|
|
|
sprintf(comp_size, "%s", origsize);
|
|
|
|
fclose(in);
|
|
for(uint32_t i = 1; i < 7; ++i)
|
|
{
|
|
uint32_t comp_return = ss_compress(filename, file_comp, i);
|
|
uint32_t deco_return = ss_decompress(file_comp, filedecout);
|
|
sprintf(retbuf, "ss: %s: compressed: %u -> %u", file_comp, deco_return, comp_return);
|
|
if(atoi(comp_size) < (int)comp_return && comp_return != 0 && deco_return != 0 && i != 1)
|
|
break;
|
|
|
|
sprintf(comp_size, "%u", comp_return);
|
|
printf("pass %u decompressed/compressed: %u/%u\n", i, deco_return, comp_return);
|
|
}
|
|
|
|
// Remove the decompressed version for sanity check
|
|
remove(filedecout);
|
|
remove(filename);
|
|
|
|
return retbuf;
|
|
}
|
|
|
|
/* mkdir function, and mkfile functions */
|
|
else if(strncmp("mkdir",tok_srch,5) == 0)
|
|
{
|
|
int parsed;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:mkdir syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"")==NULL)
|
|
{
|
|
syn_warn("ss:warn:mkdir syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
parsed = file_exists(parse_vars(tok_srch));
|
|
if(parsed == 1)
|
|
{
|
|
syn_warn("ss:warn:mkdir, file exists");
|
|
return NULL;
|
|
}
|
|
|
|
// Create directory if need pe
|
|
int mkpret = mkpath(parse_vars(tok_srch), 0755);
|
|
|
|
if(mkpret == -1)
|
|
syn_warn("ss:warn:mkdir, failed to make directory");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
else if(strncmp("mkfile",tok_srch,5) == 0)
|
|
{
|
|
int parsed;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:mkfile syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"")==NULL)
|
|
{
|
|
syn_warn("ss:warn:mkfile syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
parsed = file_exists(parse_vars(tok_srch));
|
|
if(parsed == 1)
|
|
{
|
|
syn_warn("ss:warn:mkfile, file exists");
|
|
return NULL;
|
|
}
|
|
|
|
// Create directory if need pe
|
|
int mkpret = mkpath(parse_vars(tok_srch), 0755);
|
|
|
|
if(mkpret == -1)
|
|
syn_warn("ss:warn:mkfile, failed to form parent path, attempting to write file.");
|
|
|
|
FILE *cfile = fopen(parse_vars(tok_srch), "w");
|
|
if(cfile == NULL)
|
|
{
|
|
syn_warn("ss:warn:mkfile, failed to open file");
|
|
return NULL;
|
|
}
|
|
|
|
fprintf(cfile, "%d", '\0');
|
|
fclose(cfile);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* time function */
|
|
else if(strncmp("time",tok_srch,4) == 0)
|
|
{
|
|
char *parsed;
|
|
parsed = ss_time();
|
|
return strip_nl(parsed);
|
|
}
|
|
|
|
/* isfile function */
|
|
else if(strncmp("isfile",tok_srch,5) == 0)
|
|
{
|
|
int parsed;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:isfile syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"")==NULL)
|
|
{
|
|
syn_warn("ss:warn:isfile syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
parsed = file_exists(parse_vars(tok_srch));
|
|
if(parsed == 1)
|
|
{
|
|
return "1";
|
|
}
|
|
else
|
|
{
|
|
return "0";
|
|
}
|
|
}
|
|
|
|
/* isdir function */
|
|
else if(strncmp("isdir",tok_srch,5) == 0)
|
|
{
|
|
int parsed;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:isdir syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"")==NULL)
|
|
{
|
|
syn_warn("ss:warn:isdir syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
parsed = is_dir(parse_vars(tok_srch));
|
|
if(parsed < 1)
|
|
{
|
|
return "0";
|
|
}
|
|
else
|
|
{
|
|
return "1";
|
|
}
|
|
}
|
|
|
|
/* print function */
|
|
else if(strncmp("print",tok_srch,5) == 0)
|
|
{
|
|
char *parsed;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:print syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
parsed = parse_vars(tok_srch);
|
|
if(parsed != NULL)
|
|
{
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:print syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
return parsed;
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:print compulation error, no argument?");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* sleep function */
|
|
else if(strncmp("sleep",tok_srch,5) == 0)
|
|
{
|
|
tok_srch = strtok(NULL, " ");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:sleep syntax error, need trailing integer for operation");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:sleep syntax error, need trailing integer for operation");
|
|
return NULL;
|
|
}
|
|
|
|
/* if there is a new line, remove it */
|
|
if(tok_srch[strlen(tok_srch)-1] == '\n')
|
|
{
|
|
tok_srch[strlen(tok_srch)-1] = 0;
|
|
}
|
|
sleep(atoi(parse_vars(tok_srch)));
|
|
return NULL;
|
|
}
|
|
|
|
// Calc function, some math involved! //
|
|
else if(strncmp("calc",tok_srch,5) == 0)
|
|
{
|
|
char *expr_return;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:calc syntax error, missing quotes around equation");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || (strcmp(tok_srch, " \n") == 0))
|
|
{
|
|
syn_warn("ss:warn:calc syntax error, missing equation?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:calc syntax error, missing ending quote?");
|
|
return NULL;
|
|
}
|
|
|
|
expr_return = ss_expr(parse_vars(tok_srch));
|
|
|
|
return expr_return;
|
|
}
|
|
|
|
/* Networking, listen */
|
|
else if(strncmp("netlisten",tok_srch,9) == 0)
|
|
{
|
|
char srch[MAX_NETSRCH_BUF];
|
|
char port[7]; // Should never be more than 6 characters
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing beginning quote");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing address?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strlen(parse_vars(tok_srch)) < 7)
|
|
{
|
|
strcpy(port, parse_vars(tok_srch));
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, port too long?");
|
|
return NULL;
|
|
}
|
|
|
|
/* strtok to the content that will be written to file */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing search string?");
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(srch, parse_vars(tok_srch));
|
|
|
|
/* strtok to the socket response */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing return string?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:netlisten syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
snet_listen(atoi(port), srch, parse_vars(tok_srch));
|
|
return NULL;
|
|
}
|
|
|
|
/* Networking, listen */
|
|
else if(strncmp("nethttp",tok_srch,7) == 0)
|
|
{
|
|
char port[7]; // Should never be more than 6 characters
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:nethttp syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:nethttp syntax error, missing port value?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strlen(parse_vars(tok_srch)) < 7)
|
|
{
|
|
strcpy(port, parse_vars(tok_srch));
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:nethttp syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
/* strtok to the content that will be written to file */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:nethttp syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:nethttp syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:nethttp syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(atoi(parse_vars(tok_srch)) == 1 || atoi(parse_vars(tok_srch)) == 0)
|
|
{
|
|
snet_http(atoi(port), atoi(parse_vars(tok_srch)));
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:nethttp syntax error, fork = 1, not 0");
|
|
return NULL;
|
|
}
|
|
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* Networking, connect */
|
|
else if(strncmp("nettoss",tok_srch,10) == 0)
|
|
{
|
|
char address[MAX_ADDRESS_BUF];
|
|
char data[MAX_STRING_BUFSIZE];
|
|
char port[7];
|
|
/* strtok to filename of function */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/* Check to see if syntax is correct */
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, missig address?");
|
|
return NULL;
|
|
}
|
|
|
|
/* open file */
|
|
strcpy(address, parse_vars(tok_srch));
|
|
|
|
/* strtok to the content that will be written to file */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strlen(parse_vars(tok_srch)) > 6)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, port too long");
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(port, parse_vars(tok_srch));
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, send string");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:nettoss syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
strcpy(data, parse_vars(tok_srch));
|
|
|
|
snet_toss(address, atoi(port), data);
|
|
return NULL;
|
|
}
|
|
|
|
/* ss encrypt function */
|
|
else if(strncmp("encode", tok_srch,6) == 0)
|
|
{
|
|
char *var_conv;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:encode syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:encode syntax error, encode string?");
|
|
return NULL;
|
|
}
|
|
|
|
|
|
var_conv = parse_vars(tok_srch);
|
|
if(var_conv != NULL)
|
|
{
|
|
char *encrp;
|
|
encrp = ss_encrypt(var_conv);
|
|
return encrp;
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:encode returned NULL!");
|
|
return NULL;
|
|
}
|
|
|
|
}
|
|
|
|
/* ss decrypt function */
|
|
else if(strncmp("decode", tok_srch,6) == 0)
|
|
{
|
|
char *var_conv;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:decode syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:decode syntax error, missing decode data?");
|
|
return NULL;
|
|
}
|
|
|
|
var_conv = parse_vars(tok_srch);
|
|
if(var_conv != NULL)
|
|
{
|
|
char *decrp;
|
|
decrp = ss_decrypt(var_conv);
|
|
return decrp;
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:decode returned NULL!");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* builtin md5 function */
|
|
else if(strncmp("md5",tok_srch,3) == 0)
|
|
{
|
|
char *file_line, *catfile, *file_md5_val;
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:md5 syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:md5 syntax error, need filename");
|
|
return NULL;
|
|
}
|
|
|
|
file_line = parse_vars(tok_srch);
|
|
file_md5_val = md5_file(file_line);
|
|
catfile = ss_concat(file_md5_val, file_line);
|
|
if(strlen(catfile) < MAX_CONCAT_BUF)
|
|
{
|
|
strcpy(concatbuf, catfile);
|
|
free(catfile);
|
|
return concatbuf;
|
|
}
|
|
else
|
|
{
|
|
free(catfile);
|
|
syn_warn("ss:warn:md5 returned NULL!");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* system execute function */
|
|
else if(strncmp("exec", tok_srch, 4) == 0 || strncmp("~", tok_srch, 1) == 0)
|
|
{
|
|
char *cmd_line;
|
|
int return_val;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:exec syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:exec syntax error, missing execution switch?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:exec syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
cmd_line = parse_vars(tok_srch);
|
|
return_val = system(cmd_line);
|
|
if(return_val != 0)
|
|
syn_warn("ss:warn:exec returned error code");
|
|
|
|
return NULL;
|
|
}
|
|
|
|
else if(strncmp("search",tok_srch,6) == 0)
|
|
{
|
|
char filename[MAX_FILENAME_BUFSIZE];
|
|
char *search_str, *retval;
|
|
FILE* search_file = NULL;
|
|
/* strtok to filename of function */
|
|
|
|
bzero(filename, MAX_FILENAME_LEN);
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:search syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
/* Check to see if syntax is correct */
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:search syntax error, missing filename");
|
|
return NULL;
|
|
}
|
|
|
|
/* open file */
|
|
if(MAX_FILENAME_LEN < atoi(parse_vars(tok_srch)))
|
|
{
|
|
syn_warn("ss:warn:search, filename too long");
|
|
return NULL;
|
|
}
|
|
|
|
strcat(filename, parse_vars(tok_srch));
|
|
search_file = fopen(filename, "r");
|
|
/* Check if file exists and can be opened */
|
|
if(search_file == NULL)
|
|
{
|
|
syn_warn("ss:warn:search, failed to open file");
|
|
return NULL;
|
|
}
|
|
|
|
/* strtok to the content that will be written to file */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
fclose(search_file);
|
|
syn_warn("ss:warn:search syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
fclose(search_file);
|
|
syn_warn("ss:warn:search syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
fclose(search_file);
|
|
syn_warn("ss:warn:search syntax error, missing write data?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
fclose(search_file);
|
|
syn_warn("ss:warn:search syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
search_str = parse_vars(tok_srch);
|
|
retval = strip_nl(ss_search(filename, search_file, search_str));
|
|
fclose(search_file);
|
|
return retval;
|
|
} /* search function */
|
|
|
|
|
|
/* write */
|
|
else if(strncmp("write",tok_srch,5) == 0)
|
|
{
|
|
char *filename;
|
|
char *file_content;
|
|
FILE* write_file = NULL;
|
|
/* strtok to filename of function */
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:write syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
/* Check to see if syntax is correct */
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:write syntax error, missing filename");
|
|
return NULL;
|
|
}
|
|
|
|
/* open file */
|
|
filename = parse_vars(tok_srch);
|
|
write_file = fopen(filename, "w");
|
|
/* Check if file exists and can be opened */
|
|
if(write_file == NULL)
|
|
{
|
|
syn_warn("ss:warn:write, failed to open file");
|
|
return NULL;
|
|
}
|
|
|
|
/* strtok to the content that will be written to file */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
fclose(write_file);
|
|
syn_warn("ss:warn:write syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
fclose(write_file);
|
|
syn_warn("ss:warn:write syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
fclose(write_file);
|
|
syn_warn("ss:warn:write syntax error, missing write data?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
fclose(write_file);
|
|
syn_warn("ss:warn:write syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
file_content = parse_vars(tok_srch);
|
|
fprintf(write_file, "%s\n", file_content);
|
|
fclose(write_file);
|
|
return NULL;
|
|
} /* write function */
|
|
|
|
/* read function */
|
|
else if(strncmp("read",tok_srch,4) == 0)
|
|
{
|
|
unsigned long read_size;
|
|
char read_line[1024];
|
|
char *filename, *dynfile;
|
|
FILE *read_file = NULL;
|
|
|
|
/* strtok to filename of function */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:write syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:write syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:write syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
/* Pull any variables out of the file name
|
|
that may be, and BAM, variable fill! */
|
|
filename = parse_vars(tok_srch);
|
|
|
|
// WERE LOADING FILES INTO MEMORY NOW!
|
|
/* open file */
|
|
read_file = fopen(filename, "r");
|
|
|
|
fseek(read_file, 0L, SEEK_END);
|
|
read_size = ftell(read_file);
|
|
rewind(read_file);
|
|
|
|
dynfile = (char *)malloc(read_size + 1);
|
|
|
|
*dynfile = '\0';
|
|
|
|
/* Check if file was opened successfully */
|
|
if(read_file == NULL)
|
|
{
|
|
free(dynfile);
|
|
syn_warn("ss:warn:write, failed open");
|
|
return NULL;
|
|
}
|
|
|
|
while(fgets(read_line, sizeof(read_line), read_file) != NULL)
|
|
{
|
|
strcat(dynfile, read_line);
|
|
}
|
|
|
|
if(read_size <= MAX_READFILE_LEN)
|
|
{
|
|
// Copy string to end of file, rewrite file
|
|
sprintf(filebuf, "%s", dynfile);
|
|
free(dynfile);
|
|
}
|
|
else
|
|
{
|
|
free(dynfile);
|
|
fclose(read_file);
|
|
syn_warn("ss:warn:write, file too large (2MB max)");
|
|
return NULL;
|
|
}
|
|
|
|
fclose(read_file);
|
|
|
|
return strip_nl(filebuf);
|
|
} /* read function */
|
|
|
|
/* Cat function, writes to end of file specified */
|
|
else if(strncmp("cat",tok_srch,3) == 0)
|
|
{
|
|
unsigned long read_size;
|
|
char read_line[1024];
|
|
char filename[2048+1], *dynfile;
|
|
FILE *read_file = NULL;
|
|
|
|
/* strtok to filename of function */
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:cat syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:cat syntax error, missing filename?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strlen(parse_vars(tok_srch)) < 2048)
|
|
{
|
|
strcpy(filename, parse_vars(tok_srch));
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:cat, filename too long");
|
|
return NULL;
|
|
}
|
|
|
|
// WERE LOADING FILES INTO MEMORY NOW!
|
|
/* open file */
|
|
read_file = fopen(filename, "r");
|
|
|
|
/* strtok to the content that will be written to file */
|
|
if(read_file == NULL)
|
|
{
|
|
syn_warn("ss:warn:cat, failed to open file");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
fclose(read_file);
|
|
syn_warn("ss:warn:cat syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
fclose(read_file);
|
|
syn_warn("ss:warn:cat syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
fclose(read_file);
|
|
syn_warn("ss:warn:cat syntax error, missing write data?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
fclose(read_file);
|
|
syn_warn("ss:warn:cat syntax error, missing end quote?");
|
|
return NULL;
|
|
}
|
|
|
|
fseek(read_file, 0L, SEEK_END);
|
|
read_size = ftell(read_file);
|
|
rewind(read_file);
|
|
|
|
dynfile = (char *)malloc(read_size + 1);
|
|
|
|
*dynfile = '\0';
|
|
|
|
while(fgets(read_line, sizeof(read_line), read_file) != NULL)
|
|
{
|
|
strcat(dynfile, read_line);
|
|
}
|
|
|
|
fclose(read_file);
|
|
|
|
if((read_size + strlen(parse_vars(tok_srch))) <= MAX_READFILE_LEN)
|
|
{
|
|
read_file = fopen(filename, "w");
|
|
sprintf(filebuf, "%s%s", dynfile, parse_vars(tok_srch));
|
|
fprintf(read_file, "%s", filebuf);
|
|
free(dynfile);
|
|
fclose(read_file);
|
|
}
|
|
else
|
|
{
|
|
free(dynfile);
|
|
fclose(read_file);
|
|
syn_warn("ss:warn:cat, file too large (2MB max)");
|
|
return NULL;
|
|
}
|
|
|
|
return NULL;
|
|
} /* cat function */
|
|
|
|
else if(strncmp("delete", tok_srch, 6) == 0) {
|
|
char *del_filename;
|
|
tok_srch = strtok(NULL, "\"");
|
|
if(tok_srch == NULL)
|
|
{
|
|
syn_warn("ss:warn:delete syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
if(strcmp(tok_srch, "\n") == 0 || strcmp(tok_srch, " \n") == 0)
|
|
{
|
|
syn_warn("ss:warn:delete syntax error, missing filename");
|
|
return NULL;
|
|
}
|
|
|
|
if(strtok(NULL, "\"") == NULL)
|
|
{
|
|
syn_warn("ss:warn:delete syntax error, missing quote?");
|
|
return NULL;
|
|
}
|
|
|
|
/* Pull variables out of filename if any */
|
|
del_filename = parse_vars(tok_srch);
|
|
if(access(del_filename, F_OK) == 0)
|
|
{
|
|
if(access(del_filename, W_OK) == 0)
|
|
{
|
|
remove(del_filename);
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:delete, file not accessible");
|
|
return NULL;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
syn_warn("ss:warn:delete, file not found");
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
else if(strcmp(tok_srch, "\n") != 0 && strcmp(tok_srch, "") != 0) {
|
|
if(tok_srch[strlen(tok_srch)-1] == '\n')
|
|
{
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
int varc = get_var_count();
|
|
char *varname_tmp = tok_srch;
|
|
char *bq_check;
|
|
tok_srch = strtok(NULL, "=");
|
|
|
|
// Check for back quotes, return string with backquotes processed
|
|
bq_check = strip_nl(parse_bq(parse_vars(tok_srch)));
|
|
// Don't check if variable is blank, if so let it fly!
|
|
set_var(varc, varname_tmp, bq_check);
|
|
/* printf("ss: var '%s' -> %s", varname_tmp, get_var_data(varname_tmp)); */
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|