END_TEST
#endif
START_TEST (test_fildes_many)
{
const char idsession[] = "zIDSESSION";
int dummyfd, i, killed = 0;
conn_setup();
dummyfd = open(SCANFILE, O_RDONLY);
fail_unless_fmt(dummyfd != -1, "failed to open %s: %s\n", SCANFILE, strerror(errno));
fail_unless_fmt(send(sockd, idsession, sizeof(idsession), 0) == sizeof(idsession), "send IDSESSION failed\n");
for (i=0;i<1024;i++) {
if (sendmsg_fd(sockd, "zFILDES", sizeof("zFILDES"), dummyfd, 1) == -1) {
killed = 1;
break;
}
}
close(dummyfd);
if (send(sockd, "zEND", sizeof("zEND"), 0) == -1) {
killed = 1;
}
conn_teardown();
conn_setup();
test_command("zPING", sizeof("zPING"), NULL, "PONG", 5);
conn_teardown();
}
END_TEST
#endif
#define EXPECT_INSTREAM "stream: ClamAV-Test-File.UNOFFICIAL FOUND\n"
#define EXPECT_INSTREAM0 "stream: ClamAV-Test-File.UNOFFICIAL FOUND"
#define STATS_REPLY "POOLS: 1\n\nSTATE: VALID PRIMARY\n"
START_TEST (test_stats)
{
char *recvdata;
size_t len = strlen("nSTATS\n");
int rc;
conn_setup();
rc = send(sockd, "nSTATS\n", len, 0);
fail_unless_fmt((size_t)rc == len, "Unable to send(): %s\n", strerror(errno));
recvdata = recvfull(sockd, &len);
fail_unless_fmt(len > strlen(STATS_REPLY), "Reply has wrong size: %lu, minimum %lu, reply: %s\n",
len, strlen(STATS_REPLY), recvdata);
if (len > strlen(STATS_REPLY))
len = strlen(STATS_REPLY);
rc = strncmp(recvdata, STATS_REPLY, len);
fail_unless_fmt(rc == 0, "Wrong reply: %s\n", recvdata);
free(recvdata);
conn_teardown();
}
/**
* [Client only]
* Setup the configuration for the server this client is connecting to:
* - Get server host and port.
* - Get address of server.
*
* server: Of the form server_host:server_port. The server to connect to.
* If no port is specified, defaults to port 80.
* returns: 0 on success, -1 otherwise.
*/
int do_config_server(char *server) { ASSERT_CLIENT_ONLY;
/* Parse server into its hostname and port. */
char *host, *server_port_str, *_server = server;
int server_port;
host = strsep(&server, ":");
if (server == NULL) {
fprintf(stderr, "[ERROR] No port specified for server %s\n", host);
return -1;
}
server_port_str = strsep(&server, ":");
server_port = atoi(server_port_str);
config->sconn = calloc(sizeof(conn_t), 1);
conn_add(config->sconn);
/* Get IP address of server. See if this is a server on the same machine. */
in_addr_t dst_ip = ip_from_hostname(_server);
if (dst_ip == 0)
return -1;
else if (dst_ip != LOCALHOST)
unix_socket = false;
/* Set up connection details. */
int port = server_port == 0 ? DEFAULT_PORT : server_port;
conn_setup(config->sconn, dst_ip, port, unix_socket);
return 0;
}
/**
* [Server only]
* Handle a new connection from a client. Set up connection details and
* initialize sequence numbers.
*
* pkt: The SYN segment from the client.
* returns: The conn_t associated with the new connection.
*/
conn_t *tcp_new_connection(char *pkt) { ASSERT_SERVER_ONLY;
/* Ignore if too many clients are connected. */
if (num_connected >= MAX_NUM_CLIENTS) {
fprintf(stderr, "[ERROR] Maximum number of clients (%d) reached\n",
MAX_NUM_CLIENTS);
return NULL;
}
num_connected++;
iphdr_t *ip_hdr = (iphdr_t *) pkt;
tcphdr_t *syn = (tcphdr_t *) (pkt + IP_HDR_SIZE);
/* Set up connection details and add to list of connections. */
conn_t *conn = calloc(sizeof(conn_t), 1);
conn_setup(conn, ntohl(ip_hdr->saddr), ntohs(syn->th_sport), unix_socket);
conn->their_init_seqno = ntohl(syn->th_seq);
conn->ackno = conn->their_init_seqno + 1;
conn_add(conn);
/* Send a SYN-ACK to the client. */
send_synack(conn);
/* Get window size of the client. */
ctcp_cfg->send_window = ntohs(syn->window);
ctcp_config_t *config_copy = calloc(sizeof(ctcp_config_t), 1);
memcpy(config_copy, ctcp_cfg, sizeof(ctcp_config_t));
/* Student code. */
ctcp_state_t *state = ctcp_init(conn, config_copy);
conn->state = state;
fprintf(stderr, "[INFO] Client connected\n");
return conn;
}
static void tst_fildes(const char *cmd, size_t len, int fd,
const char *expect, size_t expect_len, int closefd, int singlemsg)
{
char *recvdata, *p;
int rc;
conn_setup();
fail_unless_fmt(sendmsg_fd(sockd, cmd, len, fd, singlemsg) != -1,
"Failed to sendmsg: %s\n", strerror(errno));
if (closefd)
close(fd);
recvdata = recvfull(sockd, &len);
p = strchr(recvdata, ':');
fail_unless_fmt(!!p, "Reply doesn't contain ':' : %s\n", recvdata);
*p++ = '\0';
fail_unless_fmt(sscanf(recvdata, "fd[%u]", &rc) == 1, "Reply doesn't contain fd: %s\n", recvdata);
len -= p - recvdata;
fail_unless_fmt(len == expect_len, "Reply has wrong size: %lu, expected %lu, reply: %s, expected: %s\n",
len, expect_len, p, expect);
rc = memcmp(p, expect, expect_len);
fail_unless_fmt(!rc, "Wrong reply for command %s: |%s|, expected: |%s|\n", cmd, p, expect);
free(recvdata);
conn_teardown();
}
/* Thread used to set up a connection */
void *setup_thread( void *c )
{
conn_t *conn = c;
int oldstate;
/* Allow this thread to be killed at any time. */
pthread_setcancelstate( PTHREAD_CANCEL_ENABLE, &oldstate );
pthread_setcanceltype( PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate );
if( conn_setup( conn ) )
{
conn->last_transfer = gettime();
if( conn_exec( conn ) )
{
conn->last_transfer = gettime();
conn->enabled = 1;
conn->state = 0;
return( NULL );
}
}
conn_disconnect( conn );
conn->state = 0;
return( NULL );
}
END_TEST
START_TEST (test_idsession_stress)
{
char buf[BUFSIZ];
size_t i;
char *data, *p;
size_t len;
conn_setup();
fail_unless_fmt(send(sockd, "zIDSESSION", sizeof("zIDSESSION"), 0) == sizeof("zIDSESSION"),
"send() failed: %s\n", strerror(errno));
for (i=0;i < 1024; i++) {
snprintf(buf, sizeof(buf), "%u", (unsigned)(i+1));
fail_unless(send(sockd, "zVERSION", sizeof("zVERSION"), 0) == sizeof("zVERSION"),
"send failed: %s\n",strerror(errno));
data = recvpartial(sockd, &len, 1);
p = strchr(data, ':');
fail_unless_fmt(!!p, "wrong VERSION reply (%u): %s\n", i, data);
*p++ = '\0';
fail_unless_fmt(*p == ' ', "wrong VERSION reply (%u): %s\n", i, p);
*p++ = '\0';
fail_unless_fmt(!strcmp(p, VERSION_REPLY), "wrong VERSION reply: %s\n", data);
fail_unless_fmt(!strcmp(data, buf), "wrong IDSESSION id: %s\n", data);
free(data);
}
conn_teardown();
}
static int
_conn_sync_connect(connectionObject *self)
{
PGconn *pgconn;
int green;
/* store this value to prevent inconsistencies due to a change
* in the middle of the function. */
green = psyco_green();
if (!green) {
Py_BEGIN_ALLOW_THREADS;
self->pgconn = pgconn = PQconnectdb(self->dsn);
Py_END_ALLOW_THREADS;
Dprintf("conn_connect: new postgresql connection at %p", pgconn);
}
else {
Py_BEGIN_ALLOW_THREADS;
self->pgconn = pgconn = PQconnectStart(self->dsn);
Py_END_ALLOW_THREADS;
Dprintf("conn_connect: new green postgresql connection at %p", pgconn);
}
if (pgconn == NULL)
{
Dprintf("conn_connect: PQconnectdb(%s) FAILED", self->dsn);
PyErr_SetString(OperationalError, "PQconnectdb() failed");
return -1;
}
else if (PQstatus(pgconn) == CONNECTION_BAD)
{
Dprintf("conn_connect: PQconnectdb(%s) returned BAD", self->dsn);
PyErr_SetString(OperationalError, PQerrorMessage(pgconn));
return -1;
}
PQsetNoticeProcessor(pgconn, conn_notice_callback, (void*)self);
/* if the connection is green, wait to finish connection */
if (green) {
if (0 > pq_set_non_blocking(self, 1)) {
return -1;
}
if (0 != psyco_wait(self)) {
return -1;
}
}
/* From here the connection is considered ready: with the new status,
* poll() will use PQisBusy instead of PQconnectPoll.
*/
self->status = CONN_STATUS_READY;
if (conn_setup(self, self->pgconn) == -1) {
return -1;
}
return 0;
}
END_TEST
START_TEST (test_compat_commands)
{
/* test sending the command the "old way" */
struct basic_test *test = &basic_tests[_i];
char nsend[BUFSIZ], nreply[BUFSIZ];
if (test->skiproot && isroot)
return;
if (!test->support_old) {
snprintf(nreply, sizeof(nreply), "UNKNOWN COMMAND\n");
test->extra = NULL;
} else {
snprintf(nreply, sizeof(nreply), "%s\n", test->reply);
}
/* one command = one packet, no delimiter */
if (!test->extra) {
conn_setup();
test_command(test->command, strlen(test->command), test->extra, nreply, strlen(nreply));
conn_teardown();
}
/* one packet, \n delimited command, followed by "extra" if needed */
snprintf(nsend, sizeof(nsend), "%s\n", test->command);
conn_setup();
test_command(nsend, strlen(nsend), test->extra, nreply, strlen(nreply));
conn_teardown();
if (!test->extra) {
/* FILDES won't support this, because it expects
* strlen("FILDES\n") characters, then 1 character and the FD. */
/* one packet, \r\n delimited command, followed by "extra" if needed */
snprintf(nsend, sizeof(nsend), "%s\r\n", test->command);
conn_setup();
test_command(nsend, strlen(nsend), test->extra, nreply, strlen(nreply));
conn_teardown();
}
}
static PyObject *
psyco_conn_reset(connectionObject *self)
{
int res;
EXC_IF_CONN_CLOSED(self);
EXC_IF_CONN_ASYNC(self, reset);
if (pq_reset(self) < 0)
return NULL;
res = conn_setup(self, self->pgconn);
if (res < 0)
return NULL;
Py_RETURN_NONE;
}
static PyObject *
psyco_conn_reset(connectionObject *self, PyObject *args)
{
int res;
EXC_IF_CONN_CLOSED(self);
EXC_IF_CONN_ASYNC(self, reset);
if (pq_reset(self) < 0)
return NULL;
res = conn_setup(self, self->pgconn);
if (res < 0)
return NULL;
Py_INCREF(Py_None);
return Py_None;
}
END_TEST
START_TEST (test_stream)
{
char buf[BUFSIZ];
char *recvdata;
size_t len;
unsigned port;
int streamsd, infd, nread;
infd = open(SCANFILE, O_RDONLY);
fail_unless_fmt(infd != -1, "open failed: %s\n", strerror(errno));
conn_setup();
fail_unless_fmt(
send(sockd, "zSTREAM", sizeof("zSTREAM"), 0) == sizeof("zSTREAM"),
"send failed: %s\n", strerror(errno));
recvdata = recvpartial(sockd, &len, 1);
fail_unless_fmt (sscanf(recvdata, "PORT %u\n", &port) == 1,
"Wrong stream reply: %s\n", recvdata);
free(recvdata);
streamsd = conn_tcp(port);
do {
nread = read(infd, buf, sizeof(buf));
if (nread > 0)
fail_unless_fmt(send(streamsd, buf, nread, 0) == nread,
"send failed: %s\n", strerror(errno));
} while (nread > 0 || (nread == -1 && errno == EINTR));
fail_unless_fmt(nread != -1, "read failed: %s\n", strerror(errno));
close(infd);
close(streamsd);
recvdata = recvfull(sockd, &len);
fail_unless_fmt(!strcmp(recvdata,"stream: ClamAV-Test-File.UNOFFICIAL FOUND"),
"Wrong reply: %s\n", recvdata);
free(recvdata);
conn_teardown();
}
/**
* Send resets to previous connections, if they exist. We can tell if there are
* lots of RSTs or ACKs being sent to us.
*/
void *send_resets(void *args) {
fprintf(stderr, "[INFO] Cleaning up old connections... ");
char buf[MAX_PACKET_SIZE];
memset(buf, 0, MAX_PACKET_SIZE);
int r;
/* See if there are leftover packets. If so, send resets to them. */
r = recv(config->socket, buf, MAX_PACKET_SIZE, 0);
while (r > 0) {
handling_resets = true;
iphdr_t *ip_hdr = (iphdr_t *) buf;
tcphdr_t *tcp_hdr = (tcphdr_t *) (buf + IP_HDR_SIZE);
char *rst = create_tcp_rst(ip_hdr->saddr, tcp_hdr->th_dport,
tcp_hdr->th_sport, tcp_hdr->th_ack);
/* Create connection object to send resets to. */
conn_t conn;
memset((void *) &conn, 0, sizeof(conn_t));
conn_setup(&conn, ip_hdr->saddr, ntohs(tcp_hdr->th_sport), false);
int s = sendto(config->socket, rst, FULL_HDR_SIZE, 0,
(struct sockaddr *) &conn.saddr, sizeof(conn.saddr));
memset(buf, 0, MAX_PACKET_SIZE);
free(rst);
/* Could not send resets. Give up. */
if (s < 0)
break;
/* Continue checking for more packets to send resets to. */
handling_resets = false;
r = recv(config->socket, buf, MAX_PACKET_SIZE, 0);
}
handling_resets = false;
return NULL;
}
END_TEST
START_TEST (test_fildes_unwanted)
{
char *recvdata;
size_t len;
int dummyfd;
conn_setup();
dummyfd = open(SCANFILE, O_RDONLY);
/* send a 'zVERSION\0' including the ancillary data.
* The \0 is from the extra char needed when sending ancillary data */
fail_unless_fmt(sendmsg_fd(sockd, "zIDSESSION", strlen("zIDSESSION"), dummyfd, 1) != -1,
"sendmsg failed: %s\n", strerror(errno));
recvdata = recvfull(sockd, &len);
fail_unless_fmt(!strcmp(recvdata,"1: PROTOCOL ERROR: ancillary data sent without FILDES. ERROR"),
"Wrong reply: %s\n", recvdata);
free(recvdata);
close(dummyfd);
conn_teardown();
}
void *setup_thread_cb( void *c )
#endif
{
conn_t *conn = c;
int oldstate;
/* Allow this thread to be killed at any time. */
#if !WIN32
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
#endif
if (conn_setup(conn))
{
conn->last_transfer = gettime();
if (conn_exec(conn))
{
conn->last_transfer = gettime();
conn->enabled = 1;
conn->state = 0;
#if WIN32
return 0;
#else
return NULL;
#endif
}
}
conn_disconnect(conn);
conn->state = 0;
#if WIN32
return 0;
#else
return NULL;
#endif
}
template <> void
GncDbiBackend<DbType::DBI_SQLITE>::session_begin(QofSession* session,
const char* book_id,
bool ignore_lock,
bool create, bool force)
{
gboolean file_exists;
PairVec options;
g_return_if_fail (session != nullptr);
g_return_if_fail (book_id != nullptr);
ENTER (" ");
/* Remove uri type if present */
auto path = gnc_uri_get_path (book_id);
std::string filepath{path};
g_free(path);
GFileTest ftest = static_cast<decltype (ftest)> (
G_FILE_TEST_IS_REGULAR | G_FILE_TEST_EXISTS) ;
file_exists = g_file_test (filepath.c_str(), ftest);
if (!create && !file_exists)
{
set_error (ERR_FILEIO_FILE_NOT_FOUND);
std::string msg{"Sqlite3 file "};
set_message (msg + filepath + " not found");
PWARN ("Sqlite3 file %s not found", filepath.c_str());
LEAVE("Error");
return;
}
if (create && !force && file_exists)
{
set_error (ERR_BACKEND_STORE_EXISTS);
auto msg = "Might clobber, no force";
PWARN ("%s", msg);
LEAVE("Error");
return;
}
connect(nullptr);
/* dbi-sqlite3 documentation says that sqlite3 doesn't take a "host" option */
options.push_back(std::make_pair("host", "localhost"));
auto dirname = g_path_get_dirname (filepath.c_str());
auto basename = g_path_get_basename (filepath.c_str());
options.push_back(std::make_pair("dbname", basename));
options.push_back(std::make_pair("sqlite3_dbdir", dirname));
if (basename != nullptr) g_free (basename);
if (dirname != nullptr) g_free (dirname);
UriStrings uri;
auto conn = conn_setup(options, uri);
if (conn == nullptr)
{
LEAVE("Error");
return;
}
auto result = dbi_conn_connect (conn);
if (result < 0)
{
dbi_conn_close(conn);
PERR ("Unable to connect to %s: %d\n", book_id, result);
set_error (ERR_BACKEND_BAD_URL);
LEAVE("Error");
return;
}
if (!conn_test_dbi_library(conn))
{
if (create && !file_exists)
{
/* File didn't exist before, but it does now, and we don't want to
* leave it lying around.
*/
dbi_conn_close (conn);
conn = nullptr;
g_unlink (filepath.c_str());
}
dbi_conn_close(conn);
LEAVE("Bad DBI Library");
return;
}
try
{
connect(new GncDbiSqlConnection(DbType::DBI_SQLITE,
this, conn, ignore_lock));
}
catch (std::runtime_error& err)
{
return;
}
/* We should now have a proper session set up.
* Let's start logging */
xaccLogSetBaseName (filepath.c_str());
PINFO ("logpath=%s", filepath.c_str() ? filepath.c_str() : "(null)");
LEAVE ("");
}
END_TEST
#define TIMEOUT_REPLY "TIMED OUT WAITING FOR COMMAND\n"
START_TEST (test_connections)
{
int rc;
int i;
struct rlimit rlim;
int *sock;
int nf, maxfd=0;
fail_unless_fmt(getrlimit(RLIMIT_NOFILE, &rlim) != -1,
"Failed to get RLIMIT_NOFILE: %s\n", strerror(errno));
nf = rlim.rlim_cur - 5;
sock = malloc(sizeof(int)*nf);
fail_unless(!!sock, "malloc failed\n");
for (i=0;i<nf;i++) {
/* just open connections, and let them time out */
conn_setup_mayfail(1);
if (sockd == -1) {
nf = i;
break;
}
sock[i] = sockd;
if (sockd > maxfd)
maxfd = sockd;
}
rc = fork();
fail_unless(rc != -1, "fork() failed: %s\n", strerror(errno));
if (rc == 0) {
char dummy;
int ret;
fd_set rfds;
FD_ZERO(&rfds);
for (i=0;i<nf;i++) {
FD_SET(sock[i], &rfds);
}
while (1) {
ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
if (ret < 0)
break;
for (i=0;i<nf;i++) {
if (FD_ISSET(sock[i], &rfds)) {
if (recv(sock[i], &dummy, 1, 0) == 0) {
close(sock[i]);
FD_CLR(sock[i], &rfds);
}
}
}
}
free(sock);
exit(0);
} else {
for (i=0;i<nf;i++) {
close(sock[i]);
}
free(sock);
/* now see if clamd is able to do anything else */
for (i=0;i<10;i++) {
conn_setup();
test_command("RELOAD", sizeof("RELOAD")-1, NULL, "RELOADING\n", sizeof("RELOADING\n")-1);
conn_teardown();
}
}
}
int
main(int argc, char **argv)
{
int debug = 0, conftest = 0, nodaemon = 0;
int i = 0;
unsigned int clilen;
struct sockaddr_in cliaddr;
struct timeval start, end;
char *cnfg = DEF_CNFG;
char localhost[MAXNAMLEN + 1], path[MAXNAMLEN + 1];
FILE *pidfp;
octet_t oct;
ruleset_t *rs;
/*
* Who am I running as ?
*/
uname(&myname);
/*
* spocp_err = 0 ;
*/
memset(&srv, 0, sizeof(srv_t));
pthread_mutex_init(&(srv.mutex), NULL);
pthread_mutex_init(&(srv.mlock), NULL);
gethostname(localhost, MAXNAMLEN);
#ifdef HAVE_GETDOMAINNAME
getdomainname(path, MAXNAMLEN);
#else
{
char *pos;
if(pos = strstr(localhost, ".")) strncpy(path, pos+1, MAXNAMLEN);
else strcpy(path, "");
}
#endif
if (0)
printf("Domain: %s\n", path);
srv.hostname = Strdup(localhost);
/*
* truncating input strings to reasonable length
*/
for (i = 0; i < argc; i++)
if (strlen(argv[i]) > 512)
argv[i][512] = '\0';
while ((i = getopt(argc, argv, "Dhrtf:d:")) != EOF) {
switch (i) {
case 'D':
nodaemon = 1;
break;
case 'f':
cnfg = Strdup(optarg);
break;
case 'd':
debug = atoi(optarg);
if (debug < 0)
debug = 0;
break;
case 't':
conftest = 1;
break;
case 'r':
srv.readonly = 1;
case 'h':
default:
fprintf(stderr, "Usage: %s [-t] ", argv[0]);
fprintf(stderr, "[-f configfile] ");
fprintf(stderr, "[-D] [-d debuglevel]\n");
exit(0);
}
}
srv.root = ruleset_new(0);
if (srv_init(&srv, cnfg) < 0)
exit(1);
if (srv.port && srv.uds) {
fprintf(stderr,
"Sorry are not allowed to listen on both a unix domain socket and a port\n");
exit(1);
}
if (srv.logfile)
spocp_open_log(srv.logfile, debug);
else if (debug)
spocp_open_log(0, debug);
if (srv.name){
localcontext = (char *) Calloc(strlen(srv.name) + strlen("//") + 1,
sizeof(char));
/* Flawfinder: ignore */
sprintf(localcontext, "//%s", srv.name);
}
else {
localcontext = (char *) Calloc(strlen(localhost) + strlen("//") + 1,
sizeof(char));
/* Flawfinder: ignore */
sprintf(localcontext, "//%s", localhost);
}
/*
* where I put the access rules for access to this server and its
* rules
*/
snprintf(path, MAXNAMLEN, "%s/server", localcontext);
oct_assign(&oct, path);
if ((rs = ruleset_create(&oct, srv.root)) == 0)
exit(1);
rs->db = db_new();
/*
* access rules for operations
*/
snprintf(path, MAXNAMLEN, "%s/operation", localcontext);
oct_assign(&oct, path);
if ((rs = ruleset_create(&oct, srv.root)) == 0)
exit(1);
rs->db = db_new();
LOG(SPOCP_INFO) {
traceLog(LOG_INFO, "Local context: \"%s\"", localcontext);
traceLog(LOG_INFO, "initializing backends");
if (srv.root->db)
plugin_display(srv.plugin);
}
if (srv.plugin) {
run_plugin_init(&srv);
}
if ( get_rules( &srv ) != SPOCP_SUCCESS )
exit(1);
/*ruleset_tree( srv.root, 0);*/
/* If only testing configuration and rulefile this is as far as I go */
if (conftest) {
traceLog(LOG_INFO,"Configuration was OK");
exit(0);
}
gettimeofday(&start, NULL);
if (srv.port || srv.uds) {
/*
* stdin and stdout will not be used from here on, close to
* save file descriptors
*/
fclose(stdin);
fclose(stdout);
#ifdef HAVE_SSL
/*
* ----------------------------------------------------------
*/
/*
* build our SSL context, whether it will ever be used or not
*/
/*
* mutex'es for openSSL to use
*/
THREAD_setup();
if (srv.certificateFile && srv.privateKey && srv.caList) {
traceLog(LOG_INFO,"Initializing the TLS/SSL environment");
if (!(srv.ctx = tls_init(&srv))) {
return FALSE;
}
}
/*
* ----------------------------------------------------------
*/
#endif
#ifdef HAVE_SASL
{
int r = sasl_server_init(sasl_cb, "spocp");
if (r != SASL_OK) {
traceLog( LOG_ERR,
"Unable to initialized SASL library: %s",
sasl_errstring(r, NULL, NULL));
return FALSE;
}
}
#endif
saci_init();
if( nodaemon == 0 ) {
#ifdef HAVE_DAEMON
if (daemon(1, 1) < 0) {
fprintf(stderr, "couldn't go daemon\n");
exit(1);
}
#else
daemon_init("spocp", 0);
#endif
}
if (srv.pidfile) {
/*
* Write the PID file.
*/
pidfp = fopen(srv.pidfile, "w");
if (pidfp == (FILE *) 0) {
fprintf(stderr,
"Couldn't open pidfile \"%s\"\n",
srv.pidfile);
exit(1);
}
fprintf(pidfp, "%d\n", (int) getpid());
fclose(pidfp);
}
if (srv.port) {
LOG(SPOCP_INFO) traceLog( LOG_INFO,
"Asked to listen on port %d", srv.port);
if ((srv.listen_fd =
spocp_stream_socket(srv.port)) < 0)
exit(1);
srv.id = (char *) Malloc(16);
sprintf(srv.id, "spocp-%d", srv.port);
srv.type = AF_INET;
} else {
LOG(SPOCP_INFO)
traceLog(LOG_INFO,"Asked to listen on unix domain socket");
if ((srv.listen_fd =
spocp_unix_domain_socket(srv.uds)) < 0)
exit(1);
srv.id = (char *) Malloc(7 + strlen(srv.uds));
/* Flawfinder: ignore */
sprintf(srv.id, "spocp-%s", srv.uds);
srv.type = AF_UNIX;
}
xsignal(SIGCHLD, sig_chld);
xsignal(SIGPIPE, sig_pipe);
xsignal(SIGINT, sig_int);
xsignal(SIGTERM, sig_term);
xsignal(SIGUSR1, sig_usr1);
clilen = sizeof(cliaddr);
DEBUG(SPOCP_DSRV) traceLog(LOG_DEBUG,"Creating threads");
/*
* returns the pool the threads are picking work from
*/
srv.work = tpool_init(srv.threads, 64, 1);
spocp_srv_run(&srv);
} else {
conn_t *conn;
saci_init();
DEBUG(SPOCP_DSRV) traceLog(LOG_DEBUG,"---->");
LOG(SPOCP_INFO) traceLog(LOG_INFO,"Reading STDIN");
/*
* If I want to use this I have to do init_server() first
* conn = spocp_open_connection( STDIN_FILENO, &srv ) ;
*/
/*
* this is much simpler
*/
conn = conn_new();
conn_setup(conn, &srv, STDIN_FILENO, "localhost", "127.0.0.1");
LOG(SPOCP_INFO) traceLog(LOG_INFO,"Running server");
spocp_server((void *) conn);
gettimeofday(&end, NULL);
print_elapsed("query time:", start, end);
conn_free( conn );
}
srv_free( &srv );
if (cnfg != DEF_CNFG)
Free( cnfg );
exit(0);
}
/* Get file size and other information */
int conn_info( conn_t *conn )
{
/* It's all a bit messed up.. But it works. */
if( conn->proto == PROTO_FTP && !conn->proxy )
{
ftp_command( conn->ftp, "REST %lld", 1 );
if( ftp_wait( conn->ftp ) / 100 == 3 ||
conn->ftp->status / 100 == 2 )
{
conn->supported = 1;
ftp_command( conn->ftp, "REST %lld", 0 );
ftp_wait( conn->ftp );
}
else
{
conn->supported = 0;
}
if( !ftp_cwd( conn->ftp, conn->dir ) )
return( 0 );
conn->size = ftp_size( conn->ftp, conn->file, MAX_REDIR );
if( conn->size < 0 )
conn->supported = 0;
if( conn->size == -1 )
return( 0 );
else if( conn->size == -2 )
conn->size = INT_MAX;
}
else
{
char s[MAX_STRING], *t;
long long int i = 0;
do
{
conn->currentbyte = 1;
if( !conn_setup( conn ) )
return( 0 );
conn_exec( conn );
conn_disconnect( conn );
/* Code 3xx == redirect */
if( conn->http->status / 100 != 3 )
break;
if( ( t = http_header( conn->http, "location:" ) ) == NULL )
return( 0 );
sscanf( t, "%1023s", s ); // Warning: truncating to MAX_STRING
if( strstr( s, "://" ) == NULL)
{
sprintf( conn->http->headers, "%s%s",
conn_url( conn ), s );
strncpy( s, conn->http->headers, MAX_STRING );
}
else if( s[0] == '/' )
{
sprintf( conn->http->headers, "http://%s:%i%s",
conn->host, conn->port, s );
strncpy( s, conn->http->headers, MAX_STRING );
}
conn_set( conn, s );
i ++;
}
while( conn->http->status / 100 == 3 && i < MAX_REDIR );
if( i == MAX_REDIR )
{
sprintf( conn->message, _("Too many redirects.\n") );
return( 0 );
}
conn->size = http_size( conn->http );
if( conn->http->status == 206 && conn->size >= 0 )
{
conn->supported = 1;
conn->size ++;
}
else if( conn->http->status == 200 || conn->http->status == 206 )
{
conn->supported = 0;
conn->size = INT_MAX;
}
else
{
t = strchr( conn->message, '\n' );
if( t == NULL )
sprintf( conn->message, _("Unknown HTTP error.\n") );
else
*t = 0;
return( 0 );
}
}
return( 1 );
}
template <DbType Type> void
GncDbiBackend<Type>::session_begin (QofSession* session, const char* book_id,
bool ignore_lock, bool create, bool force)
{
GncDbiTestResult dbi_test_result = GNC_DBI_PASS;
PairVec options;
g_return_if_fail (session != nullptr);
g_return_if_fail (book_id != nullptr);
ENTER (" ");
/* Split the book-id
* Format is protocol://username:password@hostname:port/dbname
where username, password and port are optional) */
UriStrings uri(book_id);
if (Type == DbType::DBI_PGSQL)
{
if (uri.m_portnum == 0)
uri.m_portnum = PGSQL_DEFAULT_PORT;
/* Postgres's SQL interface coerces identifiers to lower case, but the
* C interface is case-sensitive. This results in a mixed-case dbname
* being created (with a lower case name) but then dbi can't conect to
* it. To work around this, coerce the name to lowercase first. */
auto lcname = g_utf8_strdown (uri.dbname(), -1);
uri.m_dbname = std::string{lcname};
g_free(lcname);
}
connect(nullptr);
auto conn = conn_setup(options, uri);
if (conn == nullptr)
{
LEAVE("Error");
return;
}
m_exists = true; //May be unset in the error handler.
auto result = dbi_conn_connect (conn);
if (result == 0)
{
if (Type == DbType::DBI_MYSQL)
adjust_sql_options (conn);
if(!conn_test_dbi_library(conn))
{
dbi_conn_close(conn);
LEAVE("Error");
return;
}
if (create && !force && save_may_clobber_data (conn,
uri.quote_dbname(Type)))
{
set_error (ERR_BACKEND_STORE_EXISTS);
PWARN ("Databse already exists, Might clobber it.");
dbi_conn_close(conn);
LEAVE("Error");
return;
}
}
else
{
if (m_exists)
{
PERR ("Unable to connect to database '%s'\n", uri.dbname());
set_error (ERR_BACKEND_SERVER_ERR);
dbi_conn_close(conn);
LEAVE("Error");
return;
}
if (create)
{
if (!create_database(conn, uri.quote_dbname(Type).c_str()))
{
dbi_conn_close(conn);
LEAVE("Error");
return;
}
conn = conn_setup(options, uri);
result = dbi_conn_connect (conn);
if (result < 0)
{
PERR ("Unable to create database '%s'\n", uri.dbname());
set_error (ERR_BACKEND_SERVER_ERR);
dbi_conn_close(conn);
LEAVE("Error");
return;
}
if (Type == DbType::DBI_MYSQL)
adjust_sql_options (conn);
if (!conn_test_dbi_library(conn))
{
if (Type == DbType::DBI_PGSQL)
dbi_conn_select_db (conn, "template1");
dbi_conn_queryf (conn, "DROP DATABASE %s",
uri.quote_dbname(Type).c_str());
dbi_conn_close(conn);
return;
}
}
else
{
set_error(ERR_BACKEND_NO_SUCH_DB);
std::string msg{"Database "};
set_message(msg + uri.dbname() + " not found");
}
}
connect(nullptr);
try
{
connect(new GncDbiSqlConnection(Type, this, conn, ignore_lock));
}
catch (std::runtime_error& err)
{
return;
}
/* We should now have a proper session set up.
* Let's start logging */
auto translog_path = gnc_build_translog_path (uri.basename().c_str());
xaccLogSetBaseName (translog_path);
PINFO ("logpath=%s", translog_path ? translog_path : "(null)");
g_free (translog_path);
LEAVE (" ");
}
int search_makelist( search_t *results, char *url )
{
int i, size = 8192, j = 0;
char *s, *s1, *s2, *s3;
conn_t conn[1];
double t;
memset( conn, 0, sizeof( conn_t ) );
conn->conf = results->conf;
t = gettime();
if( !conn_set( conn, url ) )
return( -1 );
if( !conn_init( conn ) )
return( -1 );
if( !conn_info( conn ) )
return( -1 );
strcpy( results[0].url, url );
results[0].speed = 1 + 1000 * ( gettime() - t );
results[0].size = conn->size;
s = malloc( size );
sprintf( s, "http://www.filesearching.com/cgi-bin/s?q=%s&w=a&l=en&"
"t=f&e=on&m=%i&o=n&s1=%lld&s2=%lld&x=15&y=15",
conn->file, results->conf->search_amount,
conn->size, conn->size );
conn_disconnect( conn );
memset( conn, 0, sizeof( conn_t ) );
conn->conf = results->conf;
if( !conn_set( conn, s ) )
{
free( s );
return( 1 );
}
if( !conn_setup( conn ) )
{
free( s );
return( 1 );
}
if( !conn_exec( conn ) )
{
free( s );
return( 1 );
}
while( ( i = read( conn->fd, s + j, size - j ) ) > 0 )
{
j += i;
if( j + 10 >= size )
{
size *= 2;
s = realloc( s, size );
memset( s + size / 2, 0, size / 2 );
}
}
conn_disconnect( conn );
s1 = strstr( s, "<pre class=list" );
s1 = strchr( s1, '\n' ) + 1;
if( strstr( s1, "</pre>" ) == NULL )
{
/* Incomplete list */
free( s );
return( 1 );
}
for( i = 1; strncmp( s1, "</pre>", 6 ) && i < results->conf->search_amount && *s1; i ++ )
{
s3 = strchr( s1, '\n' ); *s3 = 0;
s2 = strrstr( s1, "<a href=" ) + 8;
*s3 = '\n';
s3 = strchr( s2, ' ' ); *s3 = 0;
if( strcmp( results[0].url, s2 ) )
{
strncpy( results[i].url, s2, MAX_STRING );
results[i].size = results[0].size;
results[i].conf = results->conf;
}
else
{
/* The original URL might show up */
i --;
}
for( s1 = s3; *s1 != '\n'; s1 ++ );
s1 ++;
}
free( s );
return( i );
}
static int
redir_handle_url(struct redir_t *redir,
struct redir_conn_t *conn,
struct redir_httpreq_t *httpreq,
struct redir_socket_t *socket,
struct sockaddr_in *peer,
redir_request *req) {
int port = 80;
int matches = 1;
int i = -1;
char *p = 0;
#ifdef ENABLE_REDIRINJECT
char hasInject = 0;
if (conn->s_params.flags & UAM_INJECT_URL) {
safe_strncpy((char *) req->inject_url,
(char *) conn->s_params.url,
REDIRINJECT_MAX);
hasInject = 1;
} else if (_options.inject && *_options.inject) {
safe_strncpy((char *) req->inject_url,
(char *) _options.inject,
REDIRINJECT_MAX);
hasInject = 1;
} else {
#endif
for (i=0; i < MAX_REGEX_PASS_THROUGHS; i++) {
if ( ! _options.regex_pass_throughs[i].inuse )
break;
/*
if ( ! _options.regex_pass_throughs[i].regex_host[0] &&
! _options.regex_pass_throughs[i].regex_path[0] &&
! _options.regex_pass_throughs[i].regex_qs[0] )
break;
*/
#if(_debug_)
log_dbg("REGEX host=[%s] path=[%s] qs=[%s]",
_options.regex_pass_throughs[i].regex_host,
_options.regex_pass_throughs[i].regex_path,
_options.regex_pass_throughs[i].regex_qs);
log_dbg("Host %s", httpreq->host);
#endif
if (_options.regex_pass_throughs[i].regex_host[0]) {
switch(check_regex(&_options.regex_pass_throughs[i].re_host,
_options.regex_pass_throughs[i].regex_host,
httpreq->host)) {
case -1: return -1;
case 1: matches = _options.regex_pass_throughs[i].neg_host; break;
case 0: matches = !_options.regex_pass_throughs[i].neg_host; break;
}
}
if (matches && _options.regex_pass_throughs[i].regex_path[0]) {
switch(check_regex(&_options.regex_pass_throughs[i].re_path,
_options.regex_pass_throughs[i].regex_path,
httpreq->path)) {
case -1: return -1;
case 1: matches = _options.regex_pass_throughs[i].neg_path; break;
case 0: matches = !_options.regex_pass_throughs[i].neg_path; break;
}
}
if (matches && _options.regex_pass_throughs[i].regex_qs[0]) {
switch(check_regex(&_options.regex_pass_throughs[i].re_qs,
_options.regex_pass_throughs[i].regex_qs,
httpreq->qs)) {
case -1: return -1;
case 1: matches = _options.regex_pass_throughs[i].neg_qs; break;
case 0: matches = !_options.regex_pass_throughs[i].neg_qs; break;
}
}
if (matches) break;
}
#ifdef ENABLE_REDIRINJECT
}
#endif
if (i == 0)
matches = 0;
if (matches) {
log_dbg("Matched for Host %s", httpreq->host);
req->proxy = 1;
#ifdef ENABLE_REDIRINJECT
/* XXX */
/* Check for headers we wish to filter out */
if (hasInject) {
bstring newhdr = bfromcstr("");
char *hdr = (char *)req->wbuf->data;
if (_options.inject_wispr)
(void) inject_fmt(req, conn);
while (hdr && *hdr) {
char *p = strstr(hdr, "\r\n");
int skip = 0;
int l;
if (p) {
l = (p - hdr);
} else {
l = req->wbuf->slen - (hdr - (char*)req->wbuf->data);
}
if (!strncasecmp(hdr, "accept-encoding:", 16)) {
bcatcstr(newhdr, "Accept-Encoding: identity\r\n");
skip = 1;
} else if (!strncasecmp(hdr, "connection:", 11)) {
bcatcstr(newhdr, "Connection: close\r\n");
skip = 1;
} else if (!strncasecmp(hdr, "keep-alive:", 11)) {
skip = 1;
}
if (!skip)
bcatblk(newhdr, hdr, l);
if (p) {
if (!skip)
bcatblk(newhdr, p, 2);
hdr = p + 2;
} else {
hdr = 0;
}
}
if (req->wbuf->slen != newhdr->slen) {
log_dbg("Changed HTTP Headers");
}
bassign(req->wbuf, newhdr);
bdestroy(newhdr);
}
/* XXX */
#endif
if ((p = strchr(httpreq->host, ':'))) {
*p++ = 0;
port = atoi(p);
}
if (conn_setup(&req->conn, httpreq->host, port,
req->wbuf, req->dbuf)) {
log_err(errno, "conn_setup()");
return -1;
}
req->state |= REDIR_CONN_FD;
net_select_addfd(&sctx, req->conn.sock, SELECT_READ);
return 0;
}
return 1;
}
