void launch_thread(jobtype ptype, pkgstate* state, pkg_exec* item, pkgdata* data) {
char* arr[2];
create_script(ptype, state, item, data);
log_timestamp(1);
log_putspace(1);
if(ptype == JT_DOWNLOAD) {
log_puts(1, SPL("downloading "));
} else
log_puts(1, SPL("building "));
log_put(1, VARIS(item->name), VARISL("("), VARIS(item->scripts.filename), VARISL(") -> "), VARIS(item->scripts.stdoutfn), NULL);
arr[0] = item->scripts.filename->ptr;
arr[1] = NULL;
posix_spawn_file_actions_init(&item->fa);
posix_spawn_file_actions_addclose(&item->fa, 0);
posix_spawn_file_actions_addclose(&item->fa, 1);
posix_spawn_file_actions_addclose(&item->fa, 2);
posix_spawn_file_actions_addopen(&item->fa, 0, "/dev/null", O_RDONLY, 0);
posix_spawn_file_actions_addopen(&item->fa, 1, item->scripts.stdoutfn->ptr, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
posix_spawn_file_actions_adddup2(&item->fa, 1, 2);
int ret = posix_spawnp(&item->pid, arr[0], &item->fa, NULL, arr, environ);
if(ret == -1) {
log_perror("posix_spawn");
die(SPL(""));
}
}
static void syntax(op_state* opt) {
LOGPUTS(1, SPL("progname -listenip=0.0.0.0 -port=1080 -log=0 -uid=0 -gid=0 -user=foo -pass=bar -d\n"));
LOGPUTS(1, SPL("user and pass are regarding socks authentication\n"));
LOGPUTS(1, SPL("passed options were:\n"));
if(CONFIG_LOG) op_printall(opt);
exit(1);
}
int
islo(void)
{
int val;
val = (getpsr()&SPL(15)) == 0;
return val;
}
stringptr* make_config(pkgconfig* cfg) {
stringptr* result = stringptr_concat(
SPL("export A="),
&cfg->arch,
SPL("\n"),
SPL("export R="),
&cfg->installroot,
SPL("\n"),
SPL("export S="),
&cfg->pkgroot,
SPL("\n"),
SPL("export C="),
&cfg->filecache,
SPL("\n"),
SPL("export K="),
&cfg->keep,
SPL("\n"),
NULL);
return result;
}
int main(int argc, char** argv) {
socksserver srv;
static const char defaultip[] = "127.0.0.1";
op_state opt_storage, *opt = &opt_storage;
op_init(opt, argc, argv);
SPDECLAREC(o_port, op_get(opt, SPL("port")));
SPDECLAREC(o_listenip, op_get(opt, SPL("listenip")));
int log;
if(CONFIG_LOG) {
SPDECLAREC(o_log, op_get(opt, SPL("log")));
log = o_log->size ? strtoint(o_log->ptr, o_log->size) : 1;
} else log = 0;
int uid, gid;
if(CONFIG_IDSWITCH) {
SPDECLAREC(o_uid, op_get(opt, SPL("uid")));
SPDECLAREC(o_gid, op_get(opt, SPL("gid")));
uid = o_uid->size ? strtoint(o_uid->ptr, o_uid->size) : -1;
gid = o_gid->size ? strtoint(o_gid->ptr, o_gid->size) : -1;
} else {
uid = -1;
gid = -1;
}
SPDECLAREC(o_user, op_get(opt, SPL("user")));
SPDECLAREC(o_pass, op_get(opt, SPL("pass")));
char* ip = o_listenip->size ? o_listenip->ptr : (char*) defaultip;
int port = o_port->size ? strtoint(o_port->ptr, o_port->size) : 1080;
if(CONFIG_LOG && op_hasflag(opt, SPLITERAL("-help"))) syntax(opt);
if((o_user->size && (!o_pass->size || o_user->size > 255)) || (o_pass->size && (!o_user->size || o_pass->size > 255))) {
LOGPUTS(1, SPL("fatal: username or password exceeding 255 chars, or only one of both set\n"));
return 1;
}
if(CONFIG_DAEMONIZE && op_hasflag(opt, SPL("d"))) daemonize();
socksserver_init(&srv, ip, port, log, o_user, o_pass, uid, gid);
return 0;
}
static int socksserver_on_clientconnect (void* userdata, struct sockaddr_storage* clientaddr, int fd) {
socksserver* srv = (socksserver*) userdata;
char buffer[256];
(void) buffer;
if(CONFIG_LOG && srv->log && clientaddr) {
logstart();
printfd(fd);
LOGPUT(1, VARISL(" connect from: "), VARIC(get_client_ip(clientaddr, buffer, sizeof(buffer))), NULL);
}
if(fd < 3 || fd >= MAX_FD) {
rocksockserver_disconnect_client(&srv->serva, fd);
return -2;
}
fdinfo* client = &srv->clients[fdindex(fd)];
// put into nonblocking mode, so that writes will not block the server
int flags = fcntl(fd, F_GETFL);
if(flags == -1) return -1;
if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1) return -2;
client->data = find_free_buffer(srv);
if (!client->data) {
if(CONFIG_LOG && srv->log) {
logstart();
LOGPUTS(1, SPL("warning: couldnt find free buffer\n"));
}
rocksockserver_disconnect_client(&srv->serva, fd);
return -2;
}
client->state = SS_CONNECTED;
client->data->state = BS_IDLE;
client->data->start = 0;
client->target_fd = -1;
return 0;
}
void getconfig(pkgstate* state) {
pkgconfig* c = &state->cfg;
stringptr_fromchar(getenv("A"), &c->arch);
stringptr_fromchar(getenv("R"), &c->installroot);
stringptr_fromchar(getenv("S"), &c->pkgroot);
stringptr_fromchar(getenv("C"), &c->filecache);
stringptr_fromchar(getenv("K"), &c->keep);
stringptr_fromchar(getenv("LOGPATH"), &c->logdir);
if(!c->arch.size) {
die(SPL("need to set $A to either x86_64 or i386!\n"));
}
if(!c->installroot.size) c->installroot = *(stringptr_copy(SPL("/")));
if(!c->pkgroot.size) c->pkgroot = *(stringptr_copy(SPL("/src")));
if(!c->filecache.size) c->filecache = *(stringptr_copy(SPL("/src/tarballs")));
if(!c->keep.size) c->keep = *(stringptr_copy(SPL("/src/KEEP")));
if(!c->logdir.size) c->logdir = *(stringptr_copy(SPL("/src/logs")));
#define check_access(X) if(access(c->X.ptr, W_OK) == -1) { \
log_put(2, VARISL("cannot access "), VARISL(#X), NULL); \
log_perror(c->X.ptr); \
die(SPL("check your environment vars, if the directory exists and that you have write perm (may need root)")); \
}
check_access(logdir);
check_access(installroot);
check_access(pkgroot);
check_access(filecache);
check_access(keep);
snprintf(state->builddir_buf, sizeof(state->builddir_buf), "%s/build", c->pkgroot.ptr);
stringptr_fromchar(state->builddir_buf, &c->builddir);
if(access(state->builddir_buf, W_OK) == -1 && (errno != ENOENT || mkdir(state->builddir_buf, 0770) == -1)) {
check_access(builddir);
}
#undef check_access
}
int create_script(jobtype ptype, pkgstate* state, pkg_exec* item, pkgdata* data) {
stringptr* temp, *config, tb;
stringptr* set_cc = SPL("if [ -z \"$CC\" ] ; then\n\tCC=cc\nfi\n");
char* prefix;
char buf[256];
int hastarball;
if(ptype == JT_DOWNLOAD) {
prefix = "dl";
} else if (ptype == JT_BUILD) {
prefix = "build";
} else
abort();
item->scripts.filename = stringptr_format("%s/%s_%s.sh", state->cfg.builddir.ptr, prefix, item->name->ptr);
item->scripts.stdoutfn = stringptr_format("%s/%s_%s.log", state->cfg.logdir.ptr, prefix, item->name->ptr);
config = make_config(&state->cfg);
hastarball = get_tarball_filename(data, buf, sizeof(buf));
if(ptype == JT_DOWNLOAD) {
if(!hastarball) abort(); //bug
temp = stringptr_concat(SPL("#!/bin/sh\n"),
config,
SPL("wget -O $C/"),
stringptr_fromchar(buf, &tb),
SPL(" "),
stringptrlist_get(data->mirrors, rand() % stringptrlist_getsize(data->mirrors)),
//SPL(" --no-check-certificate"),
NULL);
} else if (ptype == JT_BUILD) {
stringptr* buildscr = stringptrlist_tostring(data->buildscript);
if(!hastarball) {
temp = stringptr_concat(SPL("#!/bin/sh\n"),
config,
set_cc,
buildscr,
NULL);
} else {
if(data->tardir->size && data->tardir->ptr[0] == '/')
// prevent erroneus scripts from trash our fs
abort();
temp = stringptr_concat(SPL("#!/bin/sh\n"),
config,
set_cc,
SPL("cd $S/build\n"),
SPL("[ -e "),
data->tardir,
SPL(" ] && rm -rf "),
data->tardir,
SPL("\ntar xf $C/"),
stringptr_fromchar(buf, &tb),
SPL(" || (echo tarball error; exit 1)\ncd $S/build/"),
data->tardir,
SPL("\n"),
buildscr,
NULL);
}
stringptr_free(buildscr);
} else abort();
stringptr_tofile(item->scripts.filename->ptr, temp);
if(chmod(item->scripts.filename->ptr, 0777) == -1) die(SPL("error setting permission"));
stringptr_free(config);
stringptr_free(temp);
return 1;
}
// contract: out is already zeroed and contains only name
void get_package_contents(pkgconfig* cfg, stringptr* packagename, pkgdata* out) {
ini_section sec;
char buf[256];
ulz_snprintf(buf, sizeof(buf), "%s/pkg/%s", cfg->pkgroot.ptr, packagename->ptr);
stringptr* fc = stringptr_fromfile(buf);
stringptr val;
if(!fc) goto err;
stringptrlist* ini = stringptr_linesplit(fc);
size_t start = 0;
stringptr* tmp;
sec = iniparser_get_section(ini, SPL("mirrors"));
out->mirrors = stringptrlist_new(sec.linecount);
for(start = sec.startline; start < sec.startline + sec.linecount; start++) {
tmp = stringptrlist_get(ini, start);
if(tmp->size) stringptrlist_add(out->mirrors, stringptr_strdup(tmp), tmp->size);
}
sec = iniparser_get_section(ini, SPL("main"));
iniparser_getvalue(ini, &sec, SPL("tardir"), &val);
if(val.size)
out->tardir = stringptr_copy(&val);
else {
// must run after mirrors!
stringptr fe;
if(get_tarball_filename(out, buf, sizeof(buf))) {
stringptr_fromchar(buf, &fe);
strip_fileext(&fe);
} else {
fe.size = 0;
fe.ptr = NULL;
}
out->tardir = stringptr_copy(&fe);
}
iniparser_getvalue(ini, &sec, SPL("sha512"), &val);
if(val.size)
out->sha512 = stringptr_copy(&val);
else
out->sha512 = NULL;
iniparser_getvalue(ini, &sec, SPL("filesize"), &val);
if(val.size)
out->filesize = strtoint64(val.ptr, val.size);
else
out->filesize = 0;
sec = iniparser_get_section(ini, SPL("deps"));
out->deps = stringptrlist_new(sec.linecount);
for(start = sec.startline; start < sec.startline + sec.linecount; start++) {
tmp = stringptrlist_get(ini, start);
if(tmp->size) stringptrlist_add(out->deps, stringptr_strdup(tmp), tmp->size);
}
sec = iniparser_get_section(ini, SPL("build")); // the build section has always to come last
if(sec.startline || sec.linecount) {
start = sec.startline;
sec = iniparser_file_as_section(ini); // iniparser may disinterpret lines starting with [
// so be sure to use the entire rest of the file
sec.startline = start;
sec.linecount -= start;
out->buildscript = stringptrlist_new(sec.linecount);
for(start = sec.startline; start < sec.startline + sec.linecount; start++) {
tmp = stringptrlist_get(ini, start);
stringptrlist_add(out->buildscript, stringptr_strdup(tmp), tmp->size);
}
} else
out->buildscript = stringptrlist_new(1);
stringptrlist_free(ini);
stringptr_free(fc);
return;
err:
log_perror(packagename->ptr);
die(SPL("package not existing"));
}
void syntax(void) {
die(SPL("syntax: pkg command options\ncommands: install, rebuild, prefetch\npass an arbitrary number of package names as options\n"));
}
static void logstart(void) {
LOGPUTS(1, SPL("["));
LOGTS(1);
LOGPUTS(1, SPL("] "));
}
DCL(8); DCL(9); DCL(10); DCL(11); DCL(12); DCL(13); DCL(14); DCL(15);
DCL(16); DCL(17); DCL(18); DCL(19); DCL(20); DCL(21); DCL(22); DCL(23);
DCL(24); DCL(25); DCL(26); DCL(27); DCL(28); DCL(29); DCL(30); DCL(31);
DCL(32); DCL(33); DCL(34); DCL(35); DCL(36); DCL(37); DCL(38); DCL(39);
DCL(40); DCL(41); DCL(42); DCL(43); DCL(44); DCL(45); DCL(46); DCL(47);
DCL(48); DCL(49); DCL(50); DCL(51); DCL(52); DCL(53); DCL(54); DCL(55);
DCL(56); DCL(57); DCL(58); DCL(59); DCL(60); DCL(61); DCL(62); DCL(63);
DCL(64); DCL(65); DCL(66); DCL(67); DCL(68); DCL(69); DCL(70); DCL(71);
DCL(72); DCL(73); DCL(74); DCL(75); DCL(76); DCL(77); DCL(78); DCL(79);
DCL(80); DCL(81); DCL(82); DCL(83); DCL(84); DCL(85); DCL(86); DCL(87);
DCL(88); DCL(89); DCL(90); DCL(91); DCL(92); DCL(93); DCL(94);
#define SPL(n) rbs_spill_##n
spill_func_t *spill_funcs[] =
{
SPL(2), SPL(3), SPL(4), SPL(5), SPL(6), SPL(7),
SPL(8), SPL(9), SPL(10), SPL(11), SPL(12), SPL(13), SPL(14), SPL(15),
SPL(16), SPL(17), SPL(18), SPL(19), SPL(20), SPL(21), SPL(22), SPL(23),
SPL(24), SPL(25), SPL(26), SPL(27), SPL(28), SPL(29), SPL(30), SPL(31),
SPL(32), SPL(33), SPL(34), SPL(35), SPL(36), SPL(37), SPL(38), SPL(39),
SPL(40), SPL(41), SPL(42), SPL(43), SPL(44), SPL(45), SPL(46), SPL(47),
SPL(48), SPL(49), SPL(50), SPL(51), SPL(52), SPL(53), SPL(54), SPL(55),
SPL(56), SPL(57), SPL(58), SPL(59), SPL(60), SPL(61), SPL(62), SPL(63),
SPL(64), SPL(65), SPL(66), SPL(67), SPL(68), SPL(69), SPL(70), SPL(71),
SPL(72), SPL(73), SPL(74), SPL(75), SPL(76), SPL(77), SPL(78), SPL(79),
SPL(80), SPL(81), SPL(82), SPL(83), SPL(84), SPL(85), SPL(86), SPL(87),
SPL(88), SPL(89), SPL(90), SPL(91), SPL(92), SPL(93), SPL(94)
};
static int verbose;
static int nerrors;
