buffp buff_realloc(buffp b, unsigned size)
{
void *p;
if (!b || !(b->buffer))
return buff_alloc(size);
if (!size)
{
buff_free(b);
return NULL;
}
p = get_mem(size);
if (!p)
{
buff_free(b);
return NULL;
}
if (size > b->alloc)
memcpy(p, b->buffer, b->alloc);
else
memcpy(p, b->buffer, size);
free_mem(b->buffer);
b->buffer = p;
b->alloc = size;
return b;
}
static void httpserver_session_free(HttpSession *session)
{
queue_remove(&session->node);
event_fd_del(session->ev);
close(session->fd);
close(session->file_fd);
if(session->request.buff)
buff_free( session->request.buff);
if(session->response)
buff_free( session->response);
}
static SList *preprocess(newspost_data *data, SList *file_list) {
Buff *tmpstring = NULL;
SList *parfiles = NULL;
/* make the from line */
if (data->name != NULL) {
tmpstring = buff_create(tmpstring, "%s", data->from->data);
data->from = buff_create(data->from, "%s <%s>",
data->name->data, tmpstring->data);
buff_free(tmpstring);
}
if (data->text == FALSE) {
/* calculate CRCs if needed; generate any sfv files */
if ((data->yenc == TRUE) || (data->sfv != NULL)) {
calculate_crcs(file_list);
if (data->sfv != NULL)
newsfv(file_list, data);
}
/* generate any par files */
if (data->par != NULL) {
parfiles = par_newspost_interface(data, file_list);
if (data->yenc == TRUE)
calculate_crcs(parfiles);
}
}
return parfiles;
}
/* returns number of bytes read */
static Buff *read_text_file(Buff *text_buffer, const char *filename) {
FILE *file;
Buff *line = NULL;
buff_free(text_buffer);
file = fopen(filename, "r");
if (file != NULL) {
while (!feof(file)) {
line = get_line(line, file);
if(line == NULL){
text_buffer = buff_add(text_buffer, "\r\n");
continue;
}
/* translate for posting */
if (line->data[0] == '.')
text_buffer = buff_add(text_buffer, ".");
text_buffer = buff_add(text_buffer, "%s", line->data);
if(text_buffer->data[(text_buffer->length - 1)] == '\r')
text_buffer = buff_add(text_buffer, "\n");
else
text_buffer = buff_add(text_buffer, "\r\n");
}
fclose(file);
}
return text_buffer;
}
static int
txdb_save_tx(struct txdb *txdb,
const uint256 *blkHash,
const uint256 *txHash,
mtime_t timestamp,
const uint8 *buf,
size_t len)
{
struct tx_ser_data txdata;
struct buff *bufd;
struct buff *bufk;
char hashStr[80];
char *err;
err = NULL;
memset(&txdata, 0, sizeof txdata);
if (blkHash) {
memcpy(&txdata.blkHash, blkHash, sizeof *blkHash);
}
txdata.buf = (uint8 *)buf;
txdata.len = len;
txdata.timestamp = timestamp;
uint256_snprintf_reverse(hashStr, sizeof hashStr, txHash);
bufk = txdb_serialize_tx_key(txdb->tx_seq, hashStr);
bufd = txdb_serialize_tx_data(&txdata);
leveldb_put(txdb->db, txdb->wr_opts,
buff_base(bufk), buff_curlen(bufk),
buff_base(bufd), buff_curlen(bufd),
&err);
buff_free(bufk);
buff_free(bufd);
if (err) {
Warning(LGPFX" failed to save tx %s: %s\n", hashStr, err);
free(err);
}
return err != NULL;
}
static void script_tx_sighash(struct wallet *wallet, uint256 *hash,
const struct buff *scriptPubKey,
const struct btc_msg_tx *tx, uint32 idx,
enum script_hash_type hashType) {
struct btc_msg_tx *tx2;
struct buff *buf;
int i;
ASSERT(idx < tx->in_count);
memset(hash, 0, sizeof *hash);
tx2 = btc_msg_tx_dup(tx);
Log(LGPFX " Computing sighash for txi-%u/%llu\n", idx, tx2->in_count);
/*
* Zero-out all the inputs' signatures.
*/
for (i = 0; i < tx2->in_count; i++) {
tx2->tx_in[i].scriptLength = 0;
}
size_t len = buff_maxlen(scriptPubKey);
ASSERT(len > 0);
ASSERT(tx2->tx_in[idx].scriptSig == NULL);
ASSERT(tx2->tx_in[idx].scriptLength == 0);
tx2->tx_in[idx].scriptLength = len;
tx2->tx_in[idx].scriptSig = safe_malloc(len);
memcpy(tx2->tx_in[idx].scriptSig, buff_base(scriptPubKey), len);
ASSERT((hashType & 0x1f) == SIGHASH_ALL);
/*
* Final step:
*
* Serialize tx + hashType (as a uint32) and compute hash.
*/
buf = buff_alloc();
serialize_tx(buf, tx2);
serialize_uint32(buf, hashType);
hash256_calc(buff_base(buf), buff_curlen(buf), hash);
buff_free(buf);
btc_msg_tx_free(tx2);
free(tx2);
}
buffp set_menu_last(buffp b)
{
MENU_NODE *pNode;
if (!b)
return b;
pNode = (MENU_NODE *)b->buffer;
if (!pNode)
{
buff_free(b);
return NULL;
}
while (pNode->next)
pNode = pNode->next;
pNode->data.menuflag |= MF_END;
return b;
}
int buff_free(Buff *buff)
{
if(--buff->ref_cnt > 0 )
return buff->ref_cnt;
if( buff->reference != NULL )
{
buff_free(buff->reference);
buff->reference=NULL;
}
else
{
free(buff->ptr);
buff->ptr=NULL;
buff->start=NULL;
}
free(buff);
return 0;
}
resp make_bitmap_resource(buffp b)
{
WORD rgb_count;
DWORD image_size;
BITMAPINFOHEADER *bmp_info_header;
BITMAP_NODE *bmp_image;
resp r;
RGBQUAD *rgb_quad;
char *bmp_bits;
r = res_new();
r->type = (strp)RT_BITMAP;
r->flags = FLAG_DEFAULT;
if (*(char *)b->buffer != 'B' ||
*(((char *)b->buffer) + 1) != 'M')
FATAL(("Invalid bitmap resource"));
ALLOC(bmp_info_header, BITMAPINFOHEADER);
get_bmp_info_header(bmp_info_header, (BYTE *)b->buffer + BMP_FILE_HEADER);
rgb_count = bit_to_rgb(bmp_info_header->biBitCount);
CALLOC(rgb_quad, rgb_count, RGBQUAD);
memcpy(rgb_quad, (BYTE *)b->buffer + BMP_FILE_HEADER + bmp_info_header->biSize,
rgb_count * sizeof(RGBQUAD));
image_size = bmp_info_header->biSizeImage;
NALLOC(bmp_bits, image_size, char *);
memcpy(bmp_bits, (BYTE *)b->buffer + BMP_FILE_HEADER +
bmp_info_header->biSize + rgb_count * sizeof(RGBQUAD),
image_size);
BUFF_STRUCT(r->b, bmp_image, BITMAP_NODE);
bmp_image->data.bmp_hdr = bmp_info_header;
bmp_image->data.rgb_quad = rgb_quad;
bmp_image->data.bitmap_bits = (BYTE*)bmp_bits;
buff_free(b);
return r;
}
void crawl_parse_free( crawl_parse_t *c ) {
buff_free( &c->buff );
}
void crawl_fetch_free( crawl_fetch_t *f ) {
free( f->url );
buff_free( &f->buff );
}
int
txdb_craft_tx(struct txdb *txdb,
const struct btc_tx_desc *tx_desc,
btc_msg_tx *tx)
{
struct buff *buf;
char hashStr[80];
uint256 txHash;
uint64 change;
uint32 numCoins;
bool relevant;
mtime_t ts;
int res;
res = 0;
relevant = 0;
tx->version = 1;
txdb_prepare_txout(tx_desc, tx);
/*
* In order to properly size 'tx->txIn', we need to determine how many coins
* we're going to use. Right now, let's just vastly overestimate.
*/
numCoins = hashtable_getnumentries(txdb->hash_txo);
tx->tx_in = safe_calloc(numCoins, sizeof *tx->tx_in);
txdb_print_coins(txdb, 1);
txdb_select_coins(txdb, tx_desc, tx, &change);
/*
* Change! XXX: fix me.
*/
if (change > 0) {
const char *btc_change;
btc_change = wallet_get_change_addr(btc->wallet);
tx->out_count++;
txdb_set_txo(tx, tx->out_count - 1, btc_change, change);
Warning(LGPFX" change: %llu -- %.8f BTC\n", change, change / ONE_BTC);
}
txdb_sign_tx_inputs(txdb, tx);
/*
* Now that the tx is ready, serialize it and check that it's not too big.
*/
btcmsg_print_tx(tx);
buf = buff_alloc();
serialize_tx(buf, tx);
if (buff_curlen(buf) > BTC_TX_MAX_SIZE) {
Warning(LGPFX" tx too large: %zu\n", buff_curlen(buf));
res = 1;
goto exit;
}
hash256_calc(buff_base(buf), buff_curlen(buf), &txHash);
uint256_snprintf_reverse(hashStr, sizeof hashStr, &txHash);
Warning(LGPFX" %s (%zu bytes)\n", hashStr, buff_curlen(buf));
Log_Bytes(LGPFX" TX: ", buff_base(buf), buff_curlen(buf));
if (bitc_testing) {
Warning("TESTING! Not saving/relaying tx.\n");
goto exit;
}
ts = time(NULL);
res = txdb_remember_tx(txdb, 0 /* save to disk */, ts,
buff_base(buf), buff_curlen(buf),
&txHash, NULL, &relevant);
txdb_save_tx_label(tx_desc, hashStr);
txdb_export_tx_info(txdb);
res = peergroup_new_tx_broadcast(btc->peerGroup, buf,
ts + 2 * 60 * 60, &txHash);
if (res) {
Warning(LGPFX" failed to transmit tx: %d\n", res);
bitcui_set_status("got errors while broadcasting tx");
}
exit:
buff_free(buf);
/*
* XXX: We should mark the coins used by this tx as "reserved", so that we
* do not attempt to use conflicting coins in subsequent TXs.
*/
return res;
}
resp make_icon_resource(buffp b)
{
BYTE *temp;
WORD i, type, count, rgb_count;
ICONDIR_NODE *cur_entry, *icon_entry_table;
ICON_NODE *cur_image;
DWORD image_offset, image_size;
BYTE *temp_offset;
BITMAPINFOHEADER *bmp_info_header;
RGBQUAD *rgb_quad;
char *XOR_bits, *AND_bits;
WORD mask_bytes;
static unsigned IdOrdinal = 1;
resp r, rIcon;
type = get_word((BYTE *)b->buffer + TYPE_OFFSET);
count = get_word((BYTE *)b->buffer + TYPE_OFFSET + 2);
if (type != 1)
FATAL(("Invalid icon resource, type=%d", type));
r = res_new();
r->type = (char *)RT_GROUP_ICON;
r->flags = FLAG_DEFAULT;
r->b = buff_alloc(count * sizeof(ICONDIR_NODE));
r->b->len = r->b->alloc;
icon_entry_table = (ICONDIR_NODE *)r->b->buffer;
cur_entry = icon_entry_table;
cur_entry->next = (ICONDIR_NODE *)NULL;
i = 0;
while (1)
{
temp = (BYTE *)b->buffer + ICON_DIR_OFFSET + i * DIR_ENTRY_SIZE;
cur_entry->data.bWidth = temp[0];
cur_entry->data.bHeight = temp[1];
cur_entry->data.wOrdinalNumber = IdOrdinal;
cur_entry->data.bColorCount = temp[2];
cur_entry->data.wPlanes = get_word(&temp[4]);
cur_entry->data.wBitsPerPel = 0; /* Unused by library */
cur_entry->data.dwBytesInRes = 0; /* Unused by library */
image_size = get_dword(&temp[8]);
image_offset = get_dword(&temp[12]);
temp_offset = (BYTE *)b->buffer + image_offset;
ALLOC(bmp_info_header, BITMAPINFOHEADER);
get_bmp_info_header(bmp_info_header, temp_offset);
temp_offset += bmp_info_header->biSize;
rgb_count = bit_to_rgb(bmp_info_header->biBitCount);
CALLOC(rgb_quad, rgb_count, RGBQUAD);
memcpy((char *)rgb_quad, (char *)temp_offset,sizeof(RGBQUAD)*rgb_count);
temp_offset += sizeof(RGBQUAD) * rgb_count;
mask_bytes = (int)(bmp_info_header->biWidth *
bmp_info_header->biHeight * bmp_info_header->biBitCount) / 16;
NALLOC(XOR_bits, mask_bytes, char *);
memcpy(XOR_bits, (char *)temp_offset, mask_bytes);
temp_offset += mask_bytes;
mask_bytes /= bmp_info_header->biBitCount;
/* AND mask is always MonoChrome */
NALLOC(AND_bits, mask_bytes, char *);
memcpy(AND_bits, (char *)temp_offset, mask_bytes);
rIcon = res_new();
BUFF_STRUCT(rIcon->b, cur_image, ICON_NODE);
cur_image->data.icon_bmp_hdr = bmp_info_header;
cur_image->data.icon_rgb_quad = rgb_quad;
cur_image->data.icon_xor_mask = (BYTE*)XOR_bits;
cur_image->data.icon_and_mask = (BYTE*)AND_bits;
rIcon->type = RT_ICON;
rIcon->name = (const char *)(IdOrdinal);
/* Flags? */
add_common_resource(rIcon);
IdOrdinal++;
if (count == ++i)
break;
else {
ALLOC(cur_entry->next, ICONDIR_NODE);
cur_entry = cur_entry->next;
cur_entry->next = (ICONDIR_NODE *)NULL;
}
}
buff_free(b);
return r;
}
void
txdb_confirm_one_tx(struct txdb *txdb,
const uint256 *blkHash,
const uint256 *txHash)
{
leveldb_iterator_t *iter;
struct tx_entry *txe;
char bkHashStr[80];
char txHashStr[80];
ASSERT(!uint256_iszero(blkHash));
ASSERT(!uint256_iszero(txHash));
txe = txdb_get_tx_entry(txdb, txHash);
if (txe == NULL) {
return;
}
if (txe->relevant == 0) {
txdb_remove_from_hashtable(txdb, txHash);
NOT_TESTED();
return;
}
if (!uint256_iszero(&txe->blkHash)) {
/*
* It's possible for the ASSERT below to fire if a tx is confirmed in
* a block that is later orphaned. The tx should then be relayed again
* until it finds its way in a new block.
*/
ASSERT(uint256_issame(&txe->blkHash, blkHash));
return;
}
peergroup_stop_broadcast_tx(btc->peerGroup, txHash);
memcpy(&txe->blkHash, blkHash, sizeof *blkHash);
uint256_snprintf_reverse(bkHashStr, sizeof bkHashStr, blkHash);
uint256_snprintf_reverse(txHashStr, sizeof txHashStr, txHash);
Warning(LGPFX" %s confirmed in %s\n", txHashStr, bkHashStr);
NOT_TESTED();
iter = leveldb_create_iterator(txdb->db, txdb->rd_opts);
leveldb_iter_seek_to_first(iter);
while (leveldb_iter_valid(iter)) {
struct tx_ser_key *txkey;
struct tx_ser_data *txdata;
struct buff *buf;
const char *key;
const char *val;
size_t klen;
size_t vlen;
char *err = NULL;
key = leveldb_iter_key(iter, &klen);
txkey = txdb_deserialize_tx_key(key, klen);
if (txkey == NULL || uint256_issame(txHash, &txkey->txHash) == 0) {
free(txkey);
leveldb_iter_next(iter);
continue;
}
NOT_TESTED();
val = leveldb_iter_value(iter, &vlen);
txdata = txdb_deserialize_tx_data(val, vlen);
ASSERT(uint256_iszero(&txdata->blkHash));
ASSERT(txdata->timestamp != 0);
memcpy(&txdata->blkHash, blkHash, sizeof *blkHash);
buf = txdb_serialize_tx_data(txdata);
leveldb_put(txdb->db, txdb->wr_opts, key, klen,
buff_base(buf), buff_curlen(buf), &err);
buff_free(buf);
if (err) {
Warning(LGPFX" failed to write tx entry: %s\n", err);
}
txdb_export_tx_info(txdb);
free(txkey);
free(txdata->buf);
free(txdata);
break;
}
leveldb_iter_destroy(iter);
}
static ex_t display_words(bfpath *bfp, int argc, char **argv, bool show_probability)
{
byte buf[BUFSIZE];
buff_t *buff = buff_new(buf, 0, BUFSIZE);
const byte *word;
const char *path = bfp->filepath;
const char *head_format = !show_probability ? "%-30s %6s %6s\n" : "%-30s %6s %6s %6s\n";
const char *data_format = !show_probability ? "%-30s %6lu %6lu\n" : "%-30s %6lu %6lu %f\n";
void *dsh = NULL; /* initialize to silence bogus gcc warning */
void *dbe;
int rv = 0;
ex_t ec = EX_OK;
dsv_t msgcnts;
/* protect against broken stat(2) that succeeds for empty names */
if (path == NULL || *path == '\0') {
fprintf(stderr, "Expecting non-empty directory or file name.\n");
return EX_ERROR;
}
dbe = ds_init(bfp);
dsh = ds_open(dbe, bfp, DS_READ);;
if (dsh == NULL)
/* print error, cleanup, and exit */
ds_open_failure(bfp, dbe);
if (DST_OK != ds_txn_begin(dsh)) {
ds_close(dsh);
ds_cleanup(dbe);
fprintf(stderr, "Cannot begin transaction.\n");
return EX_ERROR;
}
if (show_probability)
{
ds_get_msgcounts(dsh, &msgcnts);
robs = ROBS;
robx = ROBX;
}
fprintf(fpo, head_format, "", "spam", "good", " Fisher");
while (argc >= 0)
{
dsv_t val;
word_t *token;
int rc;
unsigned long spam_count;
unsigned long good_count;
double rob_prob = 0.0;
if (argc == 0)
{
if (get_token(buff, stdin) != 0)
break;
token = &buff->t;
} else {
word = (const byte *) *argv++;
if (--argc == 0)
argc = -1;
token = word_news((const char *)word);
}
rc = ds_read(dsh, token, &val);
switch (rc) {
case 0:
spam_count = val.spamcount;
good_count = val.goodcount;
if (!show_probability)
fprintf(fpo, data_format, token->u.text, spam_count, good_count);
else
{
rob_prob = calc_prob(good_count, spam_count, msgcnts.goodcount, msgcnts.spamcount);
fprintf(fpo, data_format, token->u.text, spam_count, good_count, rob_prob);
}
break;
case 1:
break;
default:
fprintf(stderr, "Cannot read from database.\n");
ec = EX_ERROR;
goto finish;
}
if (token != &buff->t)
word_free(token);
}
finish:
if (DST_OK != rv ? ds_txn_abort(dsh) : ds_txn_commit(dsh)) {
fprintf(stderr, "Cannot %s transaction.\n", rv ? "abort" : "commit");
ec = EX_ERROR;
}
ds_close(dsh);
ds_cleanup(dbe);
buff_free(buff);
return ec;
}
void res_free(resp r)
{
buff_free(r->b);
free_mem(r);
}
resp make_cursor_resource(buffp b)
{
WORD i, type, count, HotX, HotY;
CURSORDIR_NODE *cur_entry, *cursor_entry_table;
CURSOR_NODE *cur_image;
DWORD image_offset, image_size;
BYTE *temp_offset;
BITMAPINFOHEADER *bmp_info_header;
RGBQUAD *rgb_quad;
char *XOR_bits, *AND_bits;
WORD mask_bytes;
static unsigned IdOrdinal = 1;
resp r, rCursor;
type = get_word((BYTE *)b->buffer + TYPE_OFFSET);
count = get_word((BYTE *)b->buffer + TYPE_OFFSET + 2);
if (type != 2)
FATAL(("Invalid cursor resource, type=%d", type));
r = res_new();
r->type = (char *)RT_GROUP_CURSOR;
r->flags = FLAG_DEFAULT;
BUFF_STRUCT(r->b, cursor_entry_table, CURSORDIR_NODE);
cur_entry = cursor_entry_table;
cur_entry->next = NULL;
i = 0;
while (1) {
temp_offset = (BYTE *)b->buffer + CURSOR_DIR_OFFSET + i * DIR_ENTRY_SIZE;
cur_entry->data.wWidth = temp_offset[0];
cur_entry->data.wHeight = temp_offset[1];
cur_entry->data.wOrdinalNumber = IdOrdinal;
cur_entry->data.wPlanes = 0;
cur_entry->data.wBitsPerPel = 0;
cur_entry->data.dwBytesInRes = 0;
HotX = get_word((BYTE *)&temp_offset[4]);
HotY = get_word((BYTE *)&temp_offset[6]);
image_size = get_dword((BYTE *)&temp_offset[8]);
image_offset = get_dword((BYTE *)&temp_offset[12]);
temp_offset = (BYTE *)b->buffer + image_offset;
ALLOC(bmp_info_header, BITMAPINFOHEADER);
get_bmp_info_header(bmp_info_header, temp_offset);
temp_offset += bmp_info_header->biSize;
NALLOC(rgb_quad, sizeof(RGBQUAD) * 2, RGBQUAD *);
memcpy((char *)rgb_quad, (char *)temp_offset, sizeof(RGBQUAD) * 2);
temp_offset += sizeof(RGBQUAD) * 2;
mask_bytes = (bmp_info_header->biWidth + 31)/32;
mask_bytes = mask_bytes << 2;
mask_bytes = (int)(mask_bytes * bmp_info_header->biHeight)/2;
NALLOC(AND_bits, mask_bytes, char *);
NALLOC(XOR_bits, mask_bytes, char *);
memcpy(XOR_bits, (char *)temp_offset, mask_bytes);
memcpy(AND_bits, (char *)temp_offset + mask_bytes, mask_bytes);
rCursor = res_new();
BUFF_STRUCT(rCursor->b, cur_image, CURSOR_NODE);
cur_image->data.wHotSpotX = HotX;
cur_image->data.wHotSpotY = HotY;
cur_image->data.bmp_hdr = bmp_info_header;
cur_image->data.rgb_quad = rgb_quad;
cur_image->data.xor_mask = (BYTE*)XOR_bits;
cur_image->data.and_mask = (BYTE*)AND_bits;
rCursor->type = RT_CURSOR;
rCursor->name = (const char *)(IdOrdinal);
/* Flags? */
add_common_resource(rCursor);
IdOrdinal++;
if (count == ++i)
break;
else {
ALLOC(cur_entry->next, CURSORDIR_NODE);
cur_entry = cur_entry->next;
cur_entry->next = (CURSORDIR_NODE *)NULL;
}
}
buff_free(b);
return r;
}
static int post_file(newspost_data *data, file_entry *file_data,
int filenumber, int number_of_files,
const char *filestring, char *data_buffer) {
long number_of_bytes;
int j, retval;
int number_of_tries = 0;
int parts_posted = 0;
int number_of_parts =
get_number_of_encoded_parts(data, file_data);
static int total_failures = 0;
boolean posting_started = FALSE;
Buff * subject = NULL;
if(file_data->parts != NULL){
if(file_data->parts[0] == TRUE) return NORMAL;
}
for (j = 1; j <= number_of_parts; j++) {
if ((file_data->parts != NULL) &&
(file_data->parts[j] == FALSE))
continue;
subject = make_subject(subject, data, filenumber, number_of_files,
file_data->filename->data, j, number_of_parts,
filestring);
number_of_bytes = get_encoded_part(data, file_data, j,
data_buffer);
if (posting_started == FALSE) {
ui_posting_file_start(data, file_data,
number_of_parts, number_of_bytes);
posting_started = TRUE;
}
ui_posting_part_start(file_data, j, number_of_parts,
number_of_bytes);
retval = nntp_post(subject->data, data, data_buffer,
number_of_bytes, FALSE);
if (retval == NORMAL) {
ui_posting_part_done(file_data, j, number_of_parts,
number_of_bytes);
parts_posted++;
}
else if (retval == POSTING_NOT_ALLOWED)
return retval;
else {
if (number_of_tries < 5) {
ui_nntp_posting_retry();
sleep(5);
number_of_tries++;
continue;
}
else {
total_failures++;
if (total_failures == 5) {
nntp_logoff();
socket_close();
ui_too_many_failures();
}
}
}
number_of_tries = 0;
}
buff_free(subject);
ui_posting_file_done();
return NORMAL;
}
void buff_dec(buff_t *pb)
{
pb->ref--;
if(!pb->ref)
buff_free(pb);
}
static int encode_and_post(newspost_data *data, SList *file_list,
SList *parfiles) {
int number_of_parts;
int number_of_files;
int i;
file_entry *file_data = NULL;
int retval = NORMAL;
char *data_buffer =
(char *) malloc(get_buffer_size_per_encoded_part(data));
Buff *subject = NULL;
Buff *text_buffer = NULL;
/* create the socket */
ui_socket_connect_start(data->address->data);
retval = socket_create(data->address->data, data->port);
if (retval < 0)
return retval;
ui_socket_connect_done();
/* log on to the server */
ui_nntp_logon_start(data->address->data);
if (nntp_logon(data) == FALSE) {
socket_close();
return LOGON_FAILED;
}
ui_nntp_logon_done();
if (data->text == TRUE) {
file_data = file_list->data;
/* post */
text_buffer = read_text_file(text_buffer, file_data->filename->data);
if(text_buffer != NULL)
retval = nntp_post(data->subject->data, data, text_buffer->data,
text_buffer->length, TRUE);
}
else {
/* post any sfv files... */
if (data->sfv != NULL) {
file_data = file_entry_alloc(file_data);
file_data->filename =
buff_create(file_data->filename, "%s", data->sfv->data);
if (stat(data->sfv->data, &file_data->fileinfo) == -1)
ui_sfv_gen_error(data->sfv->data, errno);
else {
retval = post_file(data, file_data, 1, 1,
"SFV File", data_buffer);
if (retval < 0)
return retval;
unlink(data->sfv->data);
}
free(file_data);
}
number_of_files = slist_length(file_list);
/* if there's a prefix, post that */
if (data->prefix != NULL) {
ui_posting_prefix_start(data->prefix->data);
file_data = (file_entry *) file_list->data;
number_of_parts =
get_number_of_encoded_parts(data, file_data);
subject = make_subject(subject, data, 1 , number_of_files,
file_data->filename->data, 0 , number_of_parts,
"File");
text_buffer = read_text_file(text_buffer, data->prefix->data);
if (text_buffer != NULL) {
retval = nntp_post(subject->data, data, text_buffer->data,
text_buffer->length, TRUE);
if (retval == POSTING_NOT_ALLOWED)
return retval;
else if (retval == POSTING_FAILED) {
/* dont bother retrying...
who knows what's in that file */
ui_posting_prefix_failed();
retval = NORMAL;
}
else if (retval == NORMAL)
ui_posting_prefix_done();
}
else
ui_posting_prefix_failed();
buff_free(subject);
}
/* post the files */
i = 1;
while (file_list != NULL) {
file_data = (file_entry *) file_list->data;
retval = post_file(data, file_data, i, number_of_files,
"File", data_buffer);
if (retval < 0)
return retval;
i++;
file_list = slist_next(file_list);
}
/* post any par files */
i = 1;
file_list = parfiles;
number_of_files = slist_length(parfiles);
while (file_list != NULL) {
file_data = (file_entry *) file_list->data;
retval = post_file(data, file_data, i, number_of_files,
"PAR File", data_buffer);
if (retval < 0)
return retval;
unlink(file_data->filename->data);
buff_free(file_data->filename);
free(file_data);
i++;
file_list = slist_next(file_list);
}
slist_free(parfiles);
}
nntp_logoff();
socket_close();
free(data_buffer);
buff_free(text_buffer);
return retval;
}
