static SANE_Status read_image_duplex(SANE_Handle handle)
{
struct scanner *s = (struct scanner *) handle;
SANE_Status st = SANE_STATUS_GOOD;
unsigned read, side;
int i;
struct side {
unsigned mx, eof;
u8 *p;
struct buf *buf;
} a[2], *b;
for (i = 0; i < 2; i++) {
a[i].mx = BUF_SIZE;
a[i].eof = 0;
a[i].buf = &s->buf[i];
st = new_buf(&s->buf[i], &a[i].p);
if (st)
goto err;
}
for (b = &a[0], side = SIDE_FRONT; (!a[0].eof || !a[1].eof);) {
pthread_testcancel();
if (b->mx == 0) {
push_buf(b->buf, BUF_SIZE);
st = new_buf(b->buf, &b->p);
if (st)
goto err;
b->mx = BUF_SIZE;
}
st = kvs40xx_read_image_data(s, s->page, side,
b->p + BUF_SIZE - b->mx, b->mx,
&read);
b->mx -= read;
if (st) {
if (st != INCORRECT_LENGTH
&& st != SANE_STATUS_EOF)
goto err;
if (st == SANE_STATUS_EOF) {
b->eof = 1;
push_buf(b->buf, BUF_SIZE - b->mx);
}
side ^= SIDE_BACK;
b = &a[side == SIDE_FRONT ? 0 : 1];
}
}
err:
for (i = 0; i < 2; i++)
buf_set_st(&s->buf[i], st);
return st;
}
void func_list_mail(USER_DATA *usr) {
MAIL_DATA *pMail;
char buf[STRING];
BUFFER *buffer;
int vnum = 0;
buffer = new_buf();
add_buf(buffer, " Num Date From Subject\n\r");
for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) {
if (pMail) {
sprintf(buf, "%s %3d %s %-15s %s\n\r", pMail->marked ? "M"
: (pMail->stamp_time > pMail->read_time) ? "N" : " ", vnum
+ 1, time_str(pMail->stamp_time), pMail->from,
pMail->subject);
add_buf(buffer, buf);
vnum++;
}
}
if (vnum > 0) {
page_to_user(buf_string(buffer), usr);
free_buf(buffer);
return;
}
send_to_user("You don't have any mail.\n\r", usr);
free_buf(buffer);
return;
}
void chk_rfsbitmap(device_t * devp)
{
void * buf = new_buf(FSYS_ALCBLKSZ);
if(buf == NULL)
{
printfk("alloc buf failed\n\r");
return;
}
hal_memset(buf, FSYS_ALCBLKSZ, 0);
if(read_rfsdevblk(devp, buf, 1) == DFCERRSTUS)
{
hal_sysdie("chkbitmap err1\n\r");
}
u8_t * bmp = (u8_t *)buf;
uint_t b = 0;
for(uint_t i = 0; i<FSYS_ALCBLKSZ; i++)
{
if(bmp[i] == 0)
{
b++;
}
}
printfk("chk bmp b:%x\n\r", b);
del_buf(buf, FSYS_ALCBLKSZ);
return;
}
static const char *prep_find_entity_vnum(struct char_data *ch, const char *argument, char *arg, const char *entity,
void (*help_entity_properties_fn)(struct char_data *ch),
void (*entity_empty_fn)(struct char_data *ch, const char *arg, struct buf_type *buffer))
{
if (ch == NULL || IS_NPC(ch))
return NULL;
if (argument[0] == '\0') {
char buf[200];
snprintf(buf, 200, "\n\r%s: Find what?\n\r", entity);
send_to_char(buf, ch);
return NULL;
}
argument = one_argument(argument, arg);
if (arg[0] == '?' || !str_prefix(arg, "help")) {
show_help(ch->desc, (char *)entity, NULL);
return NULL;
}
if (!str_prefix(arg, "list")) {
(*help_entity_properties_fn)(ch);
return NULL;
} else
if (!str_prefix(arg, "empty")) {
struct buf_type *buffer = new_buf();
argument = one_argument(argument, arg);
(*entity_empty_fn)(ch, arg, buffer);
page_to_char(buf_string(buffer), ch);
free_buf(buffer);
return NULL;
}
return argument;
}
PC_DATA *new_pcdata( void )
{
static PC_DATA pcdata_zero;
PC_DATA *pcdata;
int alias;
/*~~~~~~~~~~~~~~~~~~~~~~~~*/
if ( pcdata_free == NULL )
pcdata = alloc_perm( sizeof(*pcdata) );
else
{
pcdata = pcdata_free;
pcdata_free = pcdata_free->next;
}
*pcdata = pcdata_zero;
for ( alias = 0; alias < MAX_ALIAS; alias++ )
{
pcdata->alias[alias] = NULL;
pcdata->alias_sub[alias] = NULL;
}
pcdata->buffer = new_buf( );
VALIDATE( pcdata );
return( pcdata );
}
void func_rnew_mail(USER_DATA *usr) {
MAIL_DATA *pMail;
char buf[STRING];
BUFFER *buffer;
int vnum = 1;
buffer = new_buf();
for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) {
if (pMail->stamp_time <= pMail->read_time)
break;
}
if (pMail) {
time_t *last_read = &pMail->read_time;
*last_read = UMAX(*last_read, pMail->stamp_time);
sprintf(buf, "Reading new message %d.\n\rDate: %s\n\rFrom: %s\n\r"
"Subject: %s\n\r\n\r", vnum, time_str(pMail->stamp_time),
pMail->from, pMail->subject);
add_buf(buffer, buf);
add_buf(buffer, pMail->message);
add_buf(buffer, "#x\n\r");
page_to_user(buf_string(buffer), usr);
free_buf(buffer);
save_mail(usr);
return;
}
send_to_user("No new messages.\n\r", usr);
return;
}
void *uade_ipc_set_output(const char *output)
{
if(!server_buf)
{
server_buf = new_buf();
client_buf = new_buf();
}
if(strcmp(output, "server") == 0)
return (void *)server_buf;
else
if(strcmp(output, "client") == 0)
return (void *)client_buf;
return NULL;
}
void * get_rootdirfile_blk(device_t * devp)
{
void * retptr = NULL;
rfsdir_t * rtdir = get_rootdir(devp);
if(!rtdir)
{
printfk("get_rootdir failed\n\r");
return NULL;
}
void * buf = new_buf(FSYS_ALCBLKSZ);
if(!buf)
{
printfk("new_buf failed\n\r");
retptr = NULL;
goto err2;
}
hal_memset(buf, FSYS_ALCBLKSZ, 0);
if(read_rfsdevblk(devp, buf, rtdir->rdr_blknr) == DFCERRSTUS)
{
printfk("read_rfsdevblk failed\n\r");
retptr = NULL;
goto err1;
}
retptr = buf;
goto err2;
err1:
del_buf(buf, FSYS_ALCBLKSZ);
err2:
del_rootdir(devp, rtdir);
return retptr;
}
PC_DATA *new_pcdata(void)
{
int cnt;
static PC_DATA pcdata_zero;
PC_DATA *pcdata;
if (pcdata_free == NULL)
pcdata = alloc_perm(sizeof(*pcdata));
else
{
pcdata = pcdata_free;
pcdata_free = pcdata_free->next;
}
*pcdata = pcdata_zero;
for (cnt = 0; cnt < MAX_ALIAS; cnt++)
{
pcdata->alias[cnt] = NULL;
pcdata->alias_sub[cnt] = NULL;
}
for (cnt = 0; cnt < MAX_IGNORE; cnt++) {
pcdata->ignore[cnt] = NULL;
}
for (cnt = 0; cnt < MAX_DISGUISE; cnt++) {
pcdata->disguise[cnt] = NULL;
}
pcdata->buffer = new_buf();
pcdata->polls = str_dup("");
#if !defined(FIRST_BOOT)
pcdata->learned = new_learned();
pcdata->group_known = new_gknown();
#endif
pcdata->reward_multiplier = 0;
pcdata->reward_time = current_time;
pcdata->keepoldstats = FALSE;
pcdata->referrer = str_dup("");
pcdata->forcespark = 0;
pcdata->forceinsanity = 0;
pcdata->timeoutstamp = 0;
pcdata->rprewardtimer = 0;
pcdata->rpbonus = 0;
pcdata->bondcount = 0;
pcdata->bondedbysex = 0;
pcdata->createangrealcount = 0;
pcdata->next_24hourangreal = 0;
pcdata->next_createangreal = 0;
pcdata->keys = NULL;
VALIDATE(pcdata);
return pcdata;
}
struct buffer *new_payload (struct sockaddr_in peer)
{
struct buffer *tmp = new_buf (MAX_RECV_SIZE);
if (!tmp)
return NULL;
tmp->peer = peer;
tmp->start += sizeof (struct payload_hdr);
tmp->len = 0;
return tmp;
}
bool_t create_rootdir(device_t * devp)
{
printfk("%s in \n\r", __func__);
bool_t rets = FALSE;
rfssublk_t * sbp = get_superblk(devp);
if(!sbp)
{
printfk("%s get_superblk failed\n\r");
return FALSE;
}
void * buf = new_buf(FSYS_ALCBLKSZ);
if(!buf)
{
rets = FALSE;
goto errlable1;
}
hal_memset(buf, FSYS_ALCBLKSZ, 0);
uint_t blk = rfs_new_blk(devp);
if(blk == 0)
{
rets = FALSE;
printfk("%s rfs_new_blk failed\n\r");
goto errlable;
}
sbp->rsb_rootdir.rdr_name[0] = '/';
sbp->rsb_rootdir.rdr_type = RDR_DIR_TYPE;
sbp->rsb_rootdir.rdr_blknr = blk;
fimgrhd_t * fmp = (fimgrhd_t *)buf;
fimgrhd_t_init(fmp);
fmp->fmd_type = FMD_DIR_TYPE;
fmp->fmd_sfblk = blk;
fmp->fmd_curfwritebk = blk;
fmp->fmd_curfinwbkoff = 0x200;
fmp->fmd_fleblk[0].fb_blkstart = blk;
fmp->fmd_fleblk[0].fb_blknr = 1;
if(write_rfsdevblk(devp, buf, blk) == DFCERRSTUS)
{
rets = FALSE;
goto errlable;
}
rets = TRUE;
errlable:
del_buf(buf, FSYS_ALCBLKSZ);
errlable1:
del_superblk(devp, sbp);
return rets;
}
std::vector<cuda_linear_buffer_device::ptr> layer_updater_cuda::get_data(layer_data::const_ptr host_data) const
{
std::vector<cuda_linear_buffer_device::ptr> res;
for(std::vector<std::vector<float> >::const_iterator it = host_data->begin(); it != host_data->end(); ++it)
{
size_t buffer_size = it->size() * sizeof(float);
cuda_linear_buffer_device::ptr new_buf(new cuda_linear_buffer_device(buffer_size));
cuda_safe_call(cudaMemcpy(*new_buf, &(*it->begin()), buffer_size, cudaMemcpyHostToDevice));
res.push_back(new_buf);
}
return res;
}
std::vector<cuda_linear_buffer_device::const_ptr> layer_updater_cuda::set_get_data_custom(layer_data_custom::const_ptr host_data_custom)
{
notify_data_custom(host_data_custom);
std::vector<cuda_linear_buffer_device::const_ptr> res;
for(std::vector<std::vector<int> >::const_iterator it = host_data_custom->begin(); it != host_data_custom->end(); ++it)
{
size_t buffer_size = it->size() * sizeof(int);
cuda_linear_buffer_device::ptr new_buf(new cuda_linear_buffer_device(buffer_size));
cuda_safe_call(cudaMemcpy(*new_buf, &(*it->begin()), buffer_size, cudaMemcpyHostToDevice));
res.push_back(new_buf);
}
return res;
}
PC_DATA::PC_DATA()
{
for (int alias = 0; alias < MAX_ALIAS; alias++)
{
this->alias[alias] = NULL;
this->alias_sub[alias] = NULL;
}
for ( int i = 0; i < 4; i++ ) {
this->condition[i] = 0;
}
for ( int skill = 0; skill < MAX_SKILL; skill++ ) {
this->learned[skill] = 0;
this->sk_level[skill] = 0;
this->sk_rating[skill] = 0;
}
this->next = NULL;
this->clan = NULL;
this->buffer = new_buf();
this->pwd = NULL;
this->bamfin = NULL;
this->bamfout = NULL;
this->title = NULL;
this->perm_hit = 0;
this->perm_mana = 0;
this->perm_move = 0;
this->true_sex = 0;
this->last_level = 0;
this->points = 0;
this->confirm_delete = false;
this->security = 0;
this->board = NULL;
this->in_progress = NULL;
for ( int board = 0; board < MAX_BOARD; board++ ) {
this->last_note[board] = 0;
}
for ( int group = 0; group < MAX_GROUP; group++ ) {
this->group_known[group] = false;
}
VALIDATE(this);
PC_DATA::active.push_back(this);
}
static void help_mvnum_properties(struct char_data *ch)
{
struct buf_type *buffer = new_buf();
char buf[MAX_INPUT_LENGTH];
int iter;
add_buf(buffer, "`#QUERY``: mvnum: searchable property list\n\r");
for (iter = 0; mob_idx_flags[iter].var[0] != '\0'; iter++) {
sprintf(buf, "%-18.17s", mob_idx_flags[iter].var);
add_buf(buffer, buf);
if ((iter % 2) == 1)
add_buf(buffer, "\n\r");
}
add_buf(buffer, "\n\r");
page_to_char(buf_string(buffer), ch);
free_buf(buffer);
}
void do_matlist(CHAR_DATA *ch, char *argument) {
MAT_TYPE *mat, *mat_next;
BUFFER *output = new_buf();
int col = 0;
for(mat = mat_list; mat; mat = mat_next) {
mat_next = mat->next;
add_buf(output, Format("%-15s", mat->name) );
if(++col == 5) {
col = 0;
add_buf(output, "\n\r");
}
}
page_to_char(buf_string(output), ch);
free_buf(output);
return;
}
bool_t create_bitmap(device_t * devp)
{
printfk("%s in \n\r", __func__);
bool_t rets = FALSE;
rfssublk_t * sbp = get_superblk(devp);
if(!sbp)
{
return FALSE;
}
void * buf = new_buf(FSYS_ALCBLKSZ);
if(!buf)
{
printfk("%s alloc failed\n\r", __func__);
return FALSE;
}
uint_t bitmapblk = sbp->rsb_bmpbks;
uint_t devmaxblk = sbp->rsb_fsysallblk;
if(devmaxblk > FSYS_ALCBLKSZ)
{
rets = FALSE;
goto errlable;
}
hal_memset(buf, FSYS_ALCBLKSZ, 1);
u8_t * bitmap = (u8_t *)buf;
for(uint_t bi=2; bi<devmaxblk; bi++)
{
bitmap[bi] = 0;
}
/*缓冲区数据回写到存储介质的第bitmapblk存储块中*/
if(write_rfsdevblk(devp, buf, bitmapblk) == DFCERRSTUS)
{
rets = FALSE;
goto errlable;
}
rets = TRUE;
errlable:
del_superblk(devp, sbp);
del_buf(buf, FSYS_ALCBLKSZ);
return rets;
}
rfssublk_t * get_superblk(device_t * devp)
{
void * buf = new_buf(FSYS_ALCBLKSZ);
if(!buf)
{
printfk("%s alloc failed\n\r", __func__);
return NULL;
}
hal_memset(buf, FSYS_ALCBLKSZ, 0);
if(read_rfsdevblk(devp, buf, 0)==DFCERRSTUS)
{
del_buf(buf, FSYS_ALCBLKSZ);
return NULL;
}
return (rfssublk_t *)buf;
}
void
do_mplist (CHAR_DATA * ch, char *argument)
{
int count;
MPROG_CODE *mprg;
char buf[MAX_STRING_LENGTH];
BUFFER *buffer;
buffer = new_buf ();
for (count = 1, mprg = mprog_list; mprg != NULL; mprg = mprg->next)
{
sprintf (buf, "[%3d] %5d\n\r", count, mprg->vnum);
add_buf (buffer, buf);
count++;
}
page_to_char (buf_string (buffer), ch);
free_buf (buffer);
return;
}
std::vector<const_cuda_linear_buffer_device_smart_ptr> layer_hessian_cuda::get_data_squared(const_layer_data_smart_ptr host_data) const
{
std::vector<const_cuda_linear_buffer_device_smart_ptr> res;
for(std::vector<std::vector<float> >::const_iterator it = host_data->begin(); it != host_data->end(); ++it)
{
size_t buffer_size = it->size() * sizeof(float);
cuda_linear_buffer_device_smart_ptr new_buf(new cuda_linear_buffer_device(buffer_size));
cuda_safe_call(cudaMemcpy(*new_buf, &(*it->begin()), buffer_size, cudaMemcpyHostToDevice));
cuda_util::multiply_by_itself(
*cuda_config,
*new_buf,
*new_buf,
new_buf->get_size() / sizeof(float),
0);
cuda_safe_call(cudaStreamSynchronize(0));
res.push_back(new_buf);
}
return res;
}
int main() {
MyBuf buffer = new_buf();
char c = ' ';
while(c != 'q') {
c = getchar();
getchar(); // toss the return
if(c == '1') {
on(&buffer);
} else if (c == '0') {
off(&buffer);
} else {
printf("Enter 0s and 1s\r\n");
}
printf("Value: %d\n", buffer.value);
char str[BUFFER_LENGTH+1];
buffer_inputs_to_s(&buffer, str);
printf("Inputs: %s\n", str);
}
return(0);
}
static SANE_Status read_image_simplex(SANE_Handle handle)
{
struct scanner *s = (struct scanner *) handle;
SANE_Status st = SANE_STATUS_GOOD;
for (; (!st || st == INCORRECT_LENGTH);) {
unsigned read, mx;
unsigned char *p = NULL;
st = new_buf(&s->buf[0], &p);
for (read = 0, mx = BUF_SIZE; mx &&
(!st || st == INCORRECT_LENGTH); mx -= read) {
pthread_testcancel();
st = kvs40xx_read_image_data(s, s->page, SIDE_FRONT,
p + BUF_SIZE - mx, mx,
&read);
}
push_buf(&s->buf[0], BUF_SIZE - mx);
}
buf_set_st(&s->buf[0], st);
return st;
}
bool_t create_superblk(device_t * devp)
{
printfk("%s in \n\r", __func__);
void *buf = new_buf(FSYS_ALCBLKSZ);
if(!buf)
{
printfk("alloc failed\n\r");
return FALSE;
}
hal_memset(buf, FSYS_ALCBLKSZ, 0);
rfssublk_t * sbp = (rfssublk_t *)buf;
rfssublk_t_init(sbp);
sbp->rsb_fsysallblk = ret_rfsdevmaxblknr(devp);
if(write_rfsdevblk(devp, buf, 0) == DFCERRSTUS)
{
printfk("write_rfsdevblk failed\n\r");
return FALSE;
}
del_buf(buf, FSYS_ALCBLKSZ);
return TRUE;
}
void test_dir(device_t * devp)
{
rfsdir_t * dr = get_rootdir(devp);
void * buf = new_buf(FSYS_ALCBLKSZ);
if(buf == NULL)
{
hal_sysdie("testdir1 err\n\r");
}
hal_memset(buf, FSYS_ALCBLKSZ, 0);
if(read_rfsdevblk(devp, buf, dr->rdr_blknr) == DFCERRSTUS)
{
hal_sysdie("testdir1 err\n\r");
}
fimgrhd_t * fmp = (fimgrhd_t *)buf;
printfk("fmp->fmd_type : %x fmd_filesz : %x fmd_fileifstbkoff : %x fmd_fileiendbkoff : %x\n\r",
fmp->fmd_type, fmp->fmd_filesz, fmp->fmd_fileifstbkoff, fmp->fmd_fileiendbkoff);
printfk("fmd_fleblk : %x : %x\n\r", fmp->fmd_fleblk[0].fb_blkstart, fmp->fmd_fleblk[0].fb_blknr);
del_buf(buf, FSYS_ALCBLKSZ);
del_rootdir(devp, dr);
return;
}
/*
* H : 2 bit (unsigned short)
* B : 1 bit (unsigned char)
* I : 4 bit (unsigned int)
* X : N bit (char* end up with '\0')
* x : N bit (Buffer)
*/
Buffer Buffer::pack(const char * fmt, ...)
{
Buffer rtn_buf(0);
uchar *cs = new uchar[4];
const char *str = NULL;
va_list args;
va_start(args,fmt);
while(*fmt != '\0')
{
if(*fmt == 'B') {
uchar byt = va_arg(args, uchar);
qToBigEndian(byt,cs);
rtn_buf.append(reinterpret_cast<const char *>(cs), 1);
}
if(*fmt == 'H') {
ushort dbyt = va_arg(args, ushort);
qToBigEndian(dbyt, cs);
rtn_buf.append(reinterpret_cast<const char*>(cs), 2);
}
if(*fmt == 'X') {
str = va_arg(args, const char*);
rtn_buf.append(str);
}
if(*fmt == 'x') {
Buffer new_buf(va_arg(args, Buffer));
rtn_buf.append(new_buf);
}
if(*fmt == 'I') {
uint qbyt = va_arg(args, uint);
qToBigEndian(qbyt, cs);
rtn_buf.append(reinterpret_cast<const char*>(cs), 4);
}
++fmt;
}
void func_reply_mail(USER_DATA *usr, char *argument) {
MAIL_DATA *pMail;
char buf[STRING];
BUFFER *buffer;
int vnum = 1;
int anum = 0;
if (argument[0] == '\0' || !is_number(argument)) {
syntax("[#Wr#x]eply <mail number>", usr);
return;
}
anum = atoi(argument);
buffer = new_buf();
for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) {
if (pMail && (vnum++ == anum))
break;
}
mail_attach(usr);
if (usr->pCurrentMail->to)
free_string(usr->pCurrentMail->to);
usr->pCurrentMail->to = str_dup(pMail->from);
if (usr->pCurrentMail->subject)
free_string(usr->pCurrentMail->subject);
if (pMail->subject[0] == 'R' && pMail->subject[1] == 'e'
&& pMail->subject[2] == ':' && pMail->subject[3] == ' ')
usr->pCurrentMail->subject = str_dup(pMail->subject);
else {
sprintf(buf, "Re: %s", pMail->subject);
usr->pCurrentMail->subject = str_dup(buf);
}
print_to_user(usr, "To: %s\n\rSubject: %s\n\r", usr->pCurrentMail->to,
usr->pCurrentMail->subject);
EDIT_MODE(usr) = EDITOR_MAIL_WRITE;
string_edit(usr, &usr->pCurrentMail->message);
}
/*获取根目录文件数据结构*/
rfsdir_t * get_rootdir(device_t * devp)
{
rfsdir_t * retptr = NULL;
rfssublk_t * sbp = get_superblk(devp);
if(!sbp)
{
return NULL;
}
void * buf = new_buf(sizeof(rfsdir_t));
if(!buf)
{
printfk("new_buf failed\n\r");
retptr = NULL;
goto err1;
}
hal_memcpy((void *)(&sbp->rsb_rootdir), buf, sizeof(rfsdir_t));
retptr = (rfsdir_t *)buf;
err1:
del_superblk(devp, sbp);
return retptr;
}
/*****************************************************************************
* Name: show_olc_cmds
* Purpose: Format up the commands from given table.
* Called by: show_commands(olc_act.c).
****************************************************************************/
static void show_olc_cmds(struct char_data *ch, const struct olc_cmd_type *olc_table)
{
struct buf_type *out;
char buf[MAX_STRING_LENGTH];
int cmd;
int col;
col = 0;
out = new_buf();
for (cmd = 0; olc_table[cmd].name != NULL; cmd++) {
sprintf(buf, "%-15.15s", olc_table[cmd].name);
add_buf(out, buf);
if (++col % 5 == 0)
add_buf(out, "\n\r");
}
if (col % 5 != 0)
add_buf(out, "\n\r");
send_to_char(buf_string(out), ch);
free_buf(out);
return;
}
PC_DATA *
new_pcdata (void)
{
int alias;
static PC_DATA pcdata_zero;
PC_DATA *pcdata;
if (pcdata_free == NULL)
pcdata = alloc_perm (sizeof (*pcdata));
else
{
pcdata = pcdata_free;
pcdata_free = pcdata_free->next;
}
*pcdata = pcdata_zero;
for (alias = 0; alias < MAX_ALIAS; alias++)
{
pcdata->alias[alias] = NULL;
pcdata->alias_sub[alias] = NULL;
}
for (alias = 0; alias < MAX_FORGET; alias++)
{
pcdata->forget[alias] = NULL;
}
for (alias = 0; alias < MAX_DUPES; alias++)
{
pcdata->dupes[alias] = NULL;
}
pcdata->buffer = new_buf ();
VALIDATE (pcdata);
return pcdata;
}
void func_read_mail(USER_DATA *usr, char *argument) {
MAIL_DATA *pMail;
char buf[STRING];
BUFFER *buffer;
int vnum = 1;
int anum = 0;
if (argument[0] == '\0' || !is_number(argument)) {
syntax("[#Wre#x]ad <mail number>", usr);
return;
}
anum = atoi(argument);
buffer = new_buf();
for (pMail = usr->pMailFirst; pMail; pMail = pMail->next) {
if (pMail && (vnum++ == anum)) {
time_t *last_read = &pMail->read_time;
*last_read = UMAX(*last_read, pMail->stamp_time);
sprintf(buf, "Reading message %d.\n\rDate: %s\n\rFrom: %s\n\r"
"Subject: %s\n\r\n\r", vnum - 1, time_str(pMail->stamp_time),
pMail->from, pMail->subject);
add_buf(buffer, buf);
add_buf(buffer, pMail->message);
add_buf(buffer, "#x\n\r");
page_to_user(buf_string(buffer), usr);
free_buf(buffer);
save_mail(usr);
return;
}
}
send_to_user("There aren't that many mail.\n\r", usr);
return;
}
