/* Establish data connection and return the socket descriptor */
int
ftp_pasv(int fd)
{
struct sockaddr_in sa;
char buf[MAX_LINE], *s, *e;
uint addr[4], port[2];
int ret, sock;
if (writeline(fd, "PASV\r\n") == -1)
return -1;
if (ftp_readline(fd, buf, sizeof buf) != P_OK)
return -1;
if ((s = strchr(buf, '(')) == NULL || (e = strchr(s, ')')) == NULL) {
warnx("Malformed PASV reply");
return -1;
}
s++;
*e = '\0';
ret = sscanf(s, "%u,%u,%u,%u,%u,%u",
&addr[0], &addr[1], &addr[2], &addr[3],
&port[0], &port[1]);
if (ret != 6) {
warnx("Passive mode address scan failure");
return -1;
}
memset(&sa, 0, sizeof sa);
sa.sin_family = AF_INET;
sa.sin_len = sizeof(sa);
sa.sin_addr.s_addr = htonl(pack4(addr, 0));
sa.sin_port = htons(pack2(port, 0));
if ((sock = socket(sa.sin_family, SOCK_STREAM, 0)) == -1)
err(1, "ftp_pasv: socket");
if (connect(sock, (struct sockaddr *)&sa, sa.sin_len) == -1) {
if (errno == EINTR) {
if (close(sock) == -1 && errno != EINTR)
err(1, "ftp_pasv: close");
return -1;
}
err(1, "ftp_pasv: connect");
}
return sock;
}
void PackUnix::pack(OutputFile *fo)
{
Filter ft(ph.level);
ft.addvalue = 0;
b_len = 0;
progid = 0;
// set options
blocksize = opt->o_unix.blocksize;
if (blocksize <= 0)
blocksize = BLOCKSIZE;
if ((off_t)blocksize > file_size)
blocksize = file_size;
// init compression buffers
ibuf.alloc(blocksize);
obuf.allocForCompression(blocksize);
fi->seek(0, SEEK_SET);
pack1(fo, ft); // generate Elf header, etc.
p_info hbuf;
set_te32(&hbuf.p_progid, progid);
set_te32(&hbuf.p_filesize, file_size);
set_te32(&hbuf.p_blocksize, blocksize);
fo->write(&hbuf, sizeof(hbuf));
// append the compressed body
if (pack2(fo, ft)) {
// write block end marker (uncompressed size 0)
b_info hdr; memset(&hdr, 0, sizeof(hdr));
set_le32(&hdr.sz_cpr, UPX_MAGIC_LE32);
fo->write(&hdr, sizeof(hdr));
}
pack3(fo, ft); // append loader
pack4(fo, ft); // append PackHeader and overlay_offset; update Elf header
// finally check the compression ratio
if (!checkFinalCompressionRatio(fo))
throwNotCompressible();
}
void CTimeSetMember::UpdateKeyVal(time_t new_key)
{
if(getKeyLength() == 4)
{
#ifdef PGSQL_ORM
pack4((char*)key, (char*)&new_key);
#else
DWORD t = (DWORD)new_key;
memcpy(key, &t, sizeof(DWORD));
#endif
}
else
{
#ifdef PGSQL_ORM
pack8((char*)key, (char*)&new_key);
#else
memcpy(key, &new_key, sizeof(time_t));
#endif
}
}
static int cli_send_columns(int statement, int cmd)
{
statement_desc* s = statements.get(statement);
column_binding* cb;
if (s == NULL) {
return cli_bad_descriptor;
}
long msg_size = sizeof(cli_request);
if (cmd == cli_cmd_update) {
if (!s->prepared) {
return cli_not_fetched;
}
if (s->oid == 0) {
return cli_not_found;
}
if (!s->for_update) {
return cli_not_update_mode;
}
} else {
if (!s->prepared) {
cmd = cli_cmd_prepare_and_insert;
msg_size += 1 + s->stmt_len + s->n_columns + s->columns_len;
}
}
for (cb = s->columns; cb != NULL; cb = cb->next) {
if (cb->get_fnc != NULL) {
cb->arr_ptr = cb->get_fnc(cb->var_type, cb->var_ptr, &cb->arr_len);
int len = cb->arr_len;
if (cb->var_type >= cli_array_of_oid) {
len *= sizeof_type[cb->var_type - cli_array_of_oid];
}
msg_size += 4 + len;
} else {
if (cb->var_type == cli_asciiz) {
msg_size += 4 + strlen((char*)cb->var_ptr) + 1;
} else if (cb->var_type == cli_pasciiz) {
msg_size += 4 + strlen(*(char**)cb->var_ptr) + 1;
} else if (cb->var_type >= cli_array_of_oid) {
msg_size += 4 +
*cb->var_len * sizeof_type[cb->var_type-cli_array_of_oid];
} else {
msg_size += sizeof_type[cb->var_type];
}
}
}
dbSmallBuffer buf(msg_size);
char* p = buf;
cli_request* req = (cli_request*)p;
req->length = msg_size;
req->cmd = cmd;
req->stmt_id = statement;
req->pack();
p += sizeof(cli_request);
if (cmd == cli_cmd_prepare_and_insert) {
char* cmd = s->stmt;
while ((*p++ = *cmd++) != '\0');
*p++ = s->n_columns;
for (cb = s->columns; cb != NULL; cb = cb->next) {
char* src = cb->name;
*p++ = cb->var_type;
while ((*p++ = *src++) != '\0');
}
}
for (cb = s->columns; cb != NULL; cb = cb->next) {
int n;
char* src;
if (cb->get_fnc != NULL) {
src = (char*)cb->arr_ptr;
n = cb->arr_len;
} else {
src = (char*)cb->var_ptr;
if (cb->var_type >= cli_array_of_oid) {
n = *cb->var_len;
}
}
if (cb->var_type >= cli_array_of_oid) {
p = pack4(p, n);
switch (sizeof_type[cb->var_type-cli_array_of_oid]) {
case 2:
while (--n >= 0) {
p = pack2(p, src);
src += 2;
}
break;
case 4:
while (--n >= 0) {
p = pack4(p, src);
src += 4;
}
break;
case 8:
while (--n >= 0) {
p = pack8(p, src);
src += 8;
}
break;
default:
memcpy(p, src, n);
p += n;
}
} else if (cb->var_type == cli_asciiz) {
p = pack4(p, strlen(src)+1);
while ((*p++ = *src++) != 0);
} else if (cb->var_type == cli_pasciiz) {
src = *(char**)src;
p = pack4(p, strlen(src)+1);
while ((*p++ = *src++) != 0);
} else {
switch (sizeof_type[cb->var_type]) {
case 2:
p = pack2(p, src);
break;
case 4:
p = pack4(p, src);
break;
case 8:
p = pack8(p, src);
break;
default:
*p++ = *src;
}
}
}
assert(p - buf == msg_size);
if (!s->session->sock->write(buf, msg_size)) {
return cli_network_error;
}
return cli_ok;
}
int cli_fetch(int statement, int for_update)
{
parameter_binding* pb;
column_binding* cb;
statement_desc* stmt = statements.get(statement);
char *p, *s;
if (stmt == NULL) {
return cli_bad_descriptor;
}
stmt->for_update = for_update;
int msg_size = sizeof(cli_request) + 1;
for (pb = stmt->params; pb != NULL; pb = pb->next) {
if (pb->var_ptr == NULL) {
return cli_unbound_parameter;
}
if (pb->var_type == cli_asciiz) {
msg_size += strlen((char*)pb->var_ptr) + 1;
} else if (pb->var_type == cli_pasciiz) {
msg_size += strlen(*(char**)pb->var_ptr) + 1;
} else {
msg_size += sizeof_type[pb->var_type];
}
}
stmt->oid = 0;
if (!stmt->prepared) {
msg_size += 4 + stmt->stmt_len + stmt->n_params;
msg_size += stmt->columns_len + stmt->n_columns;
}
dbSmallBuffer buf(msg_size);
p = buf;
cli_request* req = (cli_request*)p;
req->length = msg_size;
req->cmd = stmt->prepared
? cli_cmd_execute : cli_cmd_prepare_and_execute;
req->stmt_id = statement;
req->pack();
p += sizeof(cli_request);
if (!stmt->prepared) {
*p++ = stmt->n_params;
*p++ = stmt->n_columns;
p = pack2(p, stmt->stmt_len + stmt->n_params);
pb = stmt->params;
char* end = p + stmt->stmt_len + stmt->n_params;
char* src = stmt->stmt;
while (p < end) {
while ((*p++ = *src++) != '\0');
if (pb != NULL) {
*p++ = pb->var_type == cli_pasciiz ? cli_asciiz : pb->var_type;
pb = pb->next;
}
}
for (cb = stmt->columns; cb != NULL; cb = cb->next) {
*p++ = cb->var_type;
s = cb->name;
while ((*p++ = *s++) != '\0');
}
}
*p++ = for_update;
for (pb = stmt->params; pb != NULL; pb = pb->next) {
switch (pb->var_type) {
case cli_asciiz:
s = (char*)pb->var_ptr;
while ((*p++ = *s++) != '\0');
continue;
case cli_pasciiz:
s = *(char**)pb->var_ptr;
while ((*p++ = *s++) != '\0');
continue;
default:
switch (sizeof_type[pb->var_type]) {
case 1:
*p++ = *(char*)pb->var_ptr;
continue;
case 2:
p = pack2(p, *(int2*)pb->var_ptr);
continue;
case 4:
p = pack4(p, *(int4*)pb->var_ptr);
continue;
case 8:
p = pack8(p, *(int8*)pb->var_ptr);
continue;
}
}
}
assert(msg_size == p - buf);
if (!stmt->session->sock->write(buf, msg_size)) {
return cli_network_error;
}
int4 response;
if (!stmt->session->sock->read(&response, sizeof response)) {
return cli_network_error;
}
unpack4(response);
if (response >= 0) {
stmt->prepared = true;
}
return response;
}
static int cli_get_fdb(int statement, int cmd, cli_oid_t value = 0)
{
statement_desc* s = statements.get(statement);
if (s == NULL) {
return cli_bad_descriptor;
}
if (!s->prepared) {
return cli_not_fetched;
}
struct get_req {
cli_request req;
cli_oid_t value;
} get;
int length = sizeof(cli_request);
if (cmd == cli_cmd_skip) {
length += 4;
pack4((char*)(&get.req+1), (int)value);
} else if (cmd == cli_cmd_seek) {
length += sizeof(cli_oid_t);
pack_oid((char*)(&get.req+1), value);
}
get.req.length = length;
get.req.cmd = cmd;
get.req.stmt_id = statement;
get.req.pack();
if (!s->session->sock->write(&get.req, length)) {
return cli_network_error;
}
int4 response;
if (!s->session->sock->read(&response, sizeof response)) {
return cli_network_error;
}
unpack4(response);
if (response <= 0) {
return response;
}
if (s->buf_size < (size_t)response-4) {
delete[] s->buf;
s->buf_size = response-4 < DEFAULT_BUF_SIZE ? DEFAULT_BUF_SIZE : response-4;
s->buf = new char[s->buf_size];
}
char* buf = s->buf;
if (!s->session->sock->read(buf, response-4)) {
return cli_network_error;
}
char* p = buf;
int result = cli_ok;
if (cmd == cli_cmd_seek) {
s->oid = value;
result = unpack_oid(p);
} else {
s->oid = unpack_oid(p);
if (s->oid == 0) {
return cli_not_found;
}
}
p += sizeof(cli_oid_t);
for (column_binding* cb = s->columns; cb != NULL; cb = cb->next) {
int type = *p++;
if (cb->var_type == cli_any) {
cb->var_type = type;
} else {
assert(cb->var_type == type);
}
if (cb->set_fnc != NULL) {
int len = unpack4(p);
p += 4;
char* dst = (char*)cb->set_fnc(cb->var_type, cb->var_ptr, len,
cb->name, statement, p, cb->user_data);
if (dst == NULL) {
continue;
}
if (cb->var_type == cli_array_of_string) {
char** s = (char**)dst;
while (--len >= 0) {
*s++ = p;
p += strlen(p) + 1;
}
} else if (cb->var_type == cli_array_of_wstring) {
wchar_t** s = (wchar_t**)dst;
while (--len >= 0) {
*s++ = (wchar_t*)p;
p += (wcslen((wchar_t*)p) + 1)*sizeof(wchar_t);
}
} else if (cb->var_type >= cli_array_of_oid && cb->var_type < cli_array_of_string) {
switch (sizeof_type[cb->var_type-cli_array_of_oid]) {
case 2:
while (--len >= 0) {
p = unpack2(dst, p);
dst += 2;
}
break;
case 4:
while (--len >= 0) {
p = unpack4(dst, p);
dst += 4;
}
break;
case 8:
while (--len >= 0) {
p = unpack8(dst, p);
dst += 8;
}
break;
default:
memcpy(dst, p, len);
p += len;
}
} else {
memcpy(dst, p, len);
p += len;
}
} else {
if (cb->var_type >= cli_asciiz && (cb->var_type <= cli_array_of_string || cb->var_type == cli_array_of_wstring)) {
int len = unpack4(p);
p += 4;
char* dst = (char*)cb->var_ptr;
char* src = p;
int n = len;
if (cb->var_len != NULL) {
if (n > *cb->var_len) {
n = *cb->var_len;
}
*cb->var_len = n;
}
if (cb->var_type == cli_wstring || cb->var_type == cli_pwstring) {
if (cb->var_type == cli_pwstring) {
dst = *(char**)dst;
}
memcpy(dst, p, n*sizeof(wchar_t));
p += len*sizeof(wchar_t);
} else if (cb->var_type >= cli_array_of_oid) {
if (cb->var_type == cli_array_of_string) {
char** s = (char**)dst;
len -= n;
while (--n >= 0) {
*s++ = p;
p += strlen(p) + 1;
}
while (--len >= 0) {
p += strlen(p) + 1;
}
} else if (cb->var_type == cli_array_of_wstring) {
wchar_t** s = (wchar_t**)dst;
len -= n;
while (--n >= 0) {
*s++ = (wchar_t*)p;
p += (wcslen((wchar_t*)p) + 1)*sizeof(wchar_t);
}
while (--len >= 0) {
p += (wcslen((wchar_t*)p) + 1)*sizeof(wchar_t);
}
} else {
switch (sizeof_type[cb->var_type-cli_array_of_oid]) {
case 2:
while (--n >= 0) {
src = unpack2(dst, src);
dst += 2;
}
p += len*2;
break;
case 4:
while (--n >= 0) {
src = unpack4(dst, src);
dst += 4;
}
p += len*4;
break;
case 8:
while (--n >= 0) {
src = unpack8(dst, src);
dst += 8;
}
p += len*8;
break;
default:
memcpy(dst, p, n);
p += len;
}
}
} else {
if (cb->var_type == cli_pasciiz) {
dst = *(char**)dst;
}
memcpy(dst, p, n);
p += len;
}
} else if (cb->var_type == cli_rectangle) {
p = unpack_rectangle((cli_rectangle_t*)cb->var_ptr, p);
} else {
switch (sizeof_type[cb->var_type]) {
case 2:
p = unpack2((char*)cb->var_ptr, p);
break;
case 4:
p = unpack4((char*)cb->var_ptr, p);
break;
case 8:
p = unpack8((char*)cb->var_ptr, p);
break;
default:
*(char*)cb->var_ptr = *p++;
}
}
}
}
s->updated = false;
return result;
}
static int cli_send_columns_fdb(int statement, int cmd)
{
statement_desc* s = statements.get(statement);
column_binding* cb;
if (s == NULL) {
return cli_bad_descriptor;
}
long msg_size = sizeof(cli_request);
if (cmd == cli_cmd_update) {
if (!s->prepared) {
return cli_not_fetched;
}
if (s->oid == 0) {
return cli_not_found;
}
if (s->updated) {
return cli_already_updated;
}
if (!s->for_update) {
return cli_not_update_mode;
}
} else {
if (!s->prepared) {
cmd = cli_cmd_prepare_and_insert;
msg_size += 1 + s->stmt_len + s->n_columns + s->columns_len;
}
}
s->autoincrement = false;
for (cb = s->columns; cb != NULL; cb = cb->next) {
if (cb->get_fnc != NULL) {
cb->arr_ptr = cb->get_fnc(cb->var_type, cb->var_ptr, &cb->arr_len,
cb->name, statement, cb->user_data);
int len = cb->arr_len;
msg_size += 4;
if (cb->var_type == cli_array_of_string) {
char** p = (char**)cb->arr_ptr;
while (--len >= 0) {
msg_size += strlen(*p++) + 1;
}
} else if (cb->var_type == cli_array_of_wstring) {
wchar_t** p = (wchar_t**)cb->arr_ptr;
while (--len >= 0) {
msg_size += (wcslen(*p++) + 1)*sizeof(wchar_t);
}
} else if (cb->var_type == cli_wstring || cb->var_type == cli_pwstring) {
msg_size += len * sizeof(wchar_t);
} else if (cb->var_type >= cli_array_of_oid) {
msg_size += len * sizeof_type[cb->var_type - cli_array_of_oid];
} else {
msg_size += len;
}
} else {
switch (cb->var_type) {
case cli_autoincrement:
s->autoincrement = true;
break;
case cli_asciiz:
msg_size += 4 + (strlen((char*)cb->var_ptr) + 1);
break;
case cli_pasciiz:
msg_size += 4 + (strlen(*(char**)cb->var_ptr) + 1);
break;
case cli_wstring:
msg_size += 4 + (wcslen((wchar_t*)cb->var_ptr) + 1)*sizeof(wchar_t);
break;
case cli_pwstring:
msg_size += 4 + (wcslen(*(wchar_t**)cb->var_ptr) + 1)*sizeof(wchar_t);
break;
case cli_array_of_string:
{
char** p = (char**)cb->var_ptr;
int len;
msg_size += 4;
for (len = *cb->var_len; --len >= 0;) {
msg_size += (strlen(*p++) + 1);
}
break;
}
case cli_array_of_wstring:
{
wchar_t** p = (wchar_t**)cb->var_ptr;
int len;
msg_size += 4;
for (len = *cb->var_len; --len >= 0;) {
msg_size += (wcslen(*p++) + 1)*sizeof(wchar_t);
}
break;
}
default:
if (cb->var_type >= cli_array_of_oid && cb->var_type < cli_array_of_string) {
msg_size += 4 + *cb->var_len * sizeof_type[cb->var_type-cli_array_of_oid];
} else {
msg_size += sizeof_type[cb->var_type];
}
}
}
}
dbSmallBuffer buf(msg_size);
char* p = buf;
cli_request* req = (cli_request*)p;
req->length = msg_size;
req->cmd = cmd;
req->stmt_id = statement;
req->pack();
p += sizeof(cli_request);
if (cmd == cli_cmd_prepare_and_insert) {
char* cmd = s->stmt;
while ((*p++ = *cmd++) != '\0');
*p++ = s->n_columns;
for (cb = s->columns; cb != NULL; cb = cb->next) {
char* src = cb->name;
*p++ = cb->var_type;
while ((*p++ = *src++) != '\0');
}
}
for (cb = s->columns; cb != NULL; cb = cb->next) {
int n = 0;
char* src;
if (cb->get_fnc != NULL) {
src = (char*)cb->arr_ptr;
n = cb->arr_len;
} else {
src = (char*)cb->var_ptr;
if (cb->var_type >= cli_array_of_oid && (cb->var_type <= cli_array_of_string || cb->var_type == cli_array_of_wstring)) {
n = *cb->var_len;
}
}
if (cb->var_type >= cli_array_of_oid && (cb->var_type <= cli_array_of_string || cb->var_type == cli_array_of_wstring)) {
p = pack4(p, n);
if (cb->var_type == cli_array_of_string) {
while (--n >= 0) {
strcpy(p, *(char**)src);
p += strlen(p) + 1;
src += sizeof(char*);
}
} else if (cb->var_type == cli_array_of_wstring) {
while (--n >= 0) {
wcscpy((wchar_t*)p, *(wchar_t**)src);
p += (wcslen((wchar_t*)p) + 1)*sizeof(wchar_t);
src += sizeof(wchar_t*);
}
} else {
switch (sizeof_type[cb->var_type-cli_array_of_oid]) {
case 2:
while (--n >= 0) {
p = pack2(p, src);
src += 2;
}
break;
case 4:
while (--n >= 0) {
p = pack4(p, src);
src += 4;
}
break;
case 8:
while (--n >= 0) {
p = pack8(p, src);
src += 8;
}
break;
default:
memcpy(p, src, n);
p += n;
}
}
} else if (cb->var_type == cli_asciiz) {
p = pack4(p, strlen(src)+1);
while ((*p++ = *src++) != 0);
} else if (cb->var_type == cli_pasciiz) {
src = *(char**)src;
p = pack4(p, strlen(src)+1);
while ((*p++ = *src++) != 0);
} else if (cb->var_type == cli_wstring) {
wchar_t* body = (wchar_t*)src;
p = pack4(p, wcslen(body)+1);
wchar_t* dst = (wchar_t*)p;
while ((*dst++ = *body++) != 0);
p = (char*)dst;
} else if (cb->var_type == cli_pwstring) {
wchar_t* body = *(wchar_t**)src;
p = pack4(p, wcslen(body)+1);
wchar_t* dst = (wchar_t*)p;
while ((*dst++ = *body++) != 0);
p = (char*)dst;
} else if (cb->var_type == cli_rectangle) {
p = pack_rectangle(p, (cli_rectangle_t*)src);
} else if (cb->var_type != cli_autoincrement) {
switch (sizeof_type[cb->var_type]) {
case 2:
p = pack2(p, src);
break;
case 4:
p = pack4(p, src);
break;
case 8:
p = pack8(p, src);
break;
default:
*p++ = *src;
}
}
}
assert(p - buf.base() == msg_size);
if (!s->session->sock->write(buf, msg_size)) {
return cli_network_error;
}
return cli_ok;
}
