Exemple #1
0
/* Remove a note */
static void do_nremove (CHAR_DATA *ch, char *argument)
{
	NOTE_DATA *p;
	
	if (!is_number(argument))
	{
		send_to_char ("Remove which note?\n\r",ch);
		return;
	}

	p = find_note (ch, ch->pcdata->board, atoi(argument));
	if (!p)
	{
		send_to_char ("No such note.\n\r",ch);
		return;
	}
	
	if (str_cmp(ch->pcdata->switchname,p->sender) && ch->trust < MAX_LEVEL)
	{
		send_to_char ("You are not authorized to remove this note.\n\r",ch);
		return;
	}
	
	unlink_note (ch->pcdata->board,p);
	free_note (p);
	send_to_char ("Note removed!\n\r",ch);
	
	save_board(ch->pcdata->board); /* save the board */
}
Exemple #2
0
void handle_con_note_finish (DESCRIPTOR_DATA *d, char * argument)
{
        char buf[MAX_STRING_LENGTH];
	CHAR_DATA *ch = d->character;
	
		if (!ch->pcdata->in_progress)
		{
			d->connected = CON_PLAYING;
			bug ("nanny: In CON_NOTE_FINISH, but no note in progress",0);
			return;
		}
		switch (tolower(argument[0]))
		{
			case 'c': /* keep writing */
				write_to_buffer (d,"Continuing note...\n\r",0);
				d->connected = CON_NOTE_TEXT;
				break;
			case 'v': /* view note so far */
				if (ch->pcdata->in_progress->text)
				{
					write_to_buffer (d,GREEN "Text of your note so far:" NO_COLOR "\n\r",0);
					write_to_buffer (d, ch->pcdata->in_progress->text, 0);
				}
				else
					write_to_buffer (d,"You haven't written a thing!\n\r\n\r",0);
				write_to_buffer (d, szFinishPrompt, 0);
				write_to_buffer (d, "\n\r",0);
				break;
			case 'p': /* post note */
      if (board_number(ch->pcdata->board) < 4 && is_full_name("all", ch->pcdata->in_progress->to_list)) 
      {
        xprintf(buf,"A new note has been posted by %s on board %d",
          ch->name, board_number(ch->pcdata->board)+1);
        do_info(ch, buf);
      }
				finish_note (ch->pcdata->board, ch->pcdata->in_progress);
				write_to_buffer (d, "Note posted.\n\r",0);
				d->connected = CON_PLAYING;
				ch->pcdata->in_progress = NULL;
				act (BOLD GREEN "$n finishes $s note." NO_COLOR , ch, NULL, NULL, TO_ROOM);
				break;
			case 'f':
				write_to_buffer (d, "Note cancelled!\n\r",0);
				free_note (ch->pcdata->in_progress);
				ch->pcdata->in_progress = NULL;
				d->connected = CON_PLAYING;
				break;
			default: /* invalid response */
				write_to_buffer (d, "Huh? Valid answers are:\n\r\n\r",0);
				write_to_buffer (d, szFinishPrompt, 0);
				write_to_buffer (d, "\n\r",0);
		}
  if (d->connected == CON_PLAYING) REMOVE_BIT(ch->extra, EXTRA_AFK);
}
Exemple #3
0
void clear_notes(void) {
	NOTE_DATA *curr, *next;

	log_string("Cleaning: note_list");
	for(curr = note_list; curr; curr = next) {
		next = curr->next;
		free_note(curr);
	}
	note_list = NULL;

	log_string("Cleaning: idea_list");
	for(curr = idea_list; curr; curr = next) {
		next = curr->next;
		free_note(curr);
	}
	idea_list = NULL;

	log_string("Cleaning: penalty_list");
	for(curr = penalty_list; curr; curr = next) {
		next = curr->next;
		free_note(curr);
	}
	penalty_list = NULL;

	log_string("Cleaning: news_list");
	for(curr = news_list; curr; curr = next) {
		next = curr->next;
		free_note(curr);
	}
	news_list = NULL;

	log_string("Cleaning: changes_list");
	for(curr = changes_list; curr; curr = next) {
		next = curr->next;
		free_note(curr);
	}
	changes_list = NULL;

}
Exemple #4
0
void free_char (CHAR_DATA *ch)
{
    OBJ_DATA *obj;
    OBJ_DATA *obj_next;
    AFFECT_DATA *paf;
    AFFECT_DATA *paf_next;

    if (!IS_VALID(ch))
	return;

    if (IS_NPC(ch))
	mobile_count--;

    for (obj = ch->carrying; obj != NULL; obj = obj_next)
    {
	obj_next = obj->next_content;
	extract_obj(obj);
    }

    for (paf = ch->affected; paf != NULL; paf = paf_next)
    {
	paf_next = paf->next;
	affect_remove(ch,paf);
    }

    free_string(ch->name);
    free_string(ch->short_descr);
    free_string(ch->long_descr);
    free_string(ch->description);
    free_string(ch->prompt);
    free_string(ch->prefix);
    free_note  (ch->pnote);
    free_pcdata(ch->pcdata);

    ch->next = char_free;
    char_free  = ch;

    INVALIDATE(ch);
    return;
}
Exemple #5
0
void note_remove( BOARD_DATA * board, NOTE_DATA * pnote )
{
  if( !board )
  {
    bug( "note remove: null board", 0 );
    return;
  }

  if( !pnote )
  {
    bug( "note remove: null pnote", 0 );
    return;
  }

  /*
   * Remove note from linked list.
   */
  UNLINK( pnote, board->first_note, board->last_note, next, prev );

  --board->num_posts;
  free_note( pnote );
  write_board( board );
}
int
main(int argc, char *argv[])
{
	int ret = 1, i;
	dldev_t dev;
	note_t db;
	u8 *data;
	u16 len;

	/* for data security */
	/*
	umask(S_IRWXG | S_IRWXO);
	*/

	while((i = getopt(argc, argv, "hd:u:e:")) != -1){
		switch(i){
		case 'd':
			dev_file = optarg;
			break;
		case 'u':
			unused_recs = atoi(optarg);
			if(unused_recs < 0)
				unused_recs = 0;
			break;
		case 'e':
			extra_msg_len = atoi(optarg);
			if(extra_msg_len < 0)
				extra_msg_len = 0;
			break;
		case 'h':
		default:
			usage();
			break;
		}
	}
	argc -= optind;
	argv += optind;

	set_note_unused_recs(unused_recs);
	set_note_extra_len(extra_msg_len);

#ifdef USB_USBHID
	dev.usb.file = dev_file;
#endif

	if(open_dev(&dev)){
		ERROR("open_dev");
		goto exit;
	}

	if(start_session(&dev)){
		ERROR("read_app_info");
		goto exit;
	}

/******************************************************************************/
#ifdef DEBUG
	for(i = 0; i < NUM_APPS; i++){
		if(!dev.app[i].acd.app_idx)
			continue;
		printf("%2d: %d%d%d%d%d%d%d%d %02x %02x %04x %04x %04x %04x %04x %04x %s\n", i,
				dev.app[i].acd.app_idx,
				dev.app[i].acd.code_loc,
				dev.app[i].acd.db_loc,
				dev.app[i].acd.code_invalid,
				dev.app[i].acd.db_modified,
				dev.app[i].acd.db_invalid,
				dev.app[i].acd.passwd_req,
				dev.app[i].acd.mode_name,

				dev.app[i].acb.app_type,
				dev.app[i].acb.app_inst,
				dev.app[i].acb.asd_addr,
				dev.app[i].acb.add_addr,
				dev.app[i].acb.state_mgr_addr,
				dev.app[i].acb.refresh_addr,
				dev.app[i].acb.banner_addr,
				dev.app[i].acb.code_addr,
				dev.app[i].banner
		);
	}
#endif
/******************************************************************************/

	if(read_note_mem(&dev, &db)){
		ERROR("read_note_mem");
		goto end;
	}

	create_note(&db, &data, &len);
	if(load_add(&dev, find_app(&dev, "NOTE"), data)){
		ERROR("load_add");
		goto end;
	}
	free(data);

	print_note(&db, stdout);
	free_note(&db);

/******************************************************************************/
end:
	if(end_session(&dev)){
		ERROR("end_session");
		goto exit;
	}

	ret = 0;
exit:
	close_dev(&dev);

	exit(ret);
}
Exemple #7
0
void parse_note( CHAR_DATA *ch, char *argument, int type )
{
    BUFFER *buffer;
    char buf[MAX_STRING_LENGTH], query[MSL];
    char arg[MAX_INPUT_LENGTH];
    MYSQL_RES *res;
    MYSQL_ROW row;
    char *list_name;
    int vnum;
    int anum;

    switch(type)
    {
	default:
	    return;
        case NOTE_NOTE:
	    list_name = "notes";
            break;
        case NOTE_IDEA:
	    list_name = "ideas";
            break;
        case NOTE_PENALTY:
	    list_name = "penalties";
            break;
        case NOTE_NEWS:
	    list_name = "news";
            break;
        case NOTE_CHANGES:
	    list_name = "changes";
            break;
    }

    argument = one_argument( argument, arg );
    smash_tilde( argument );

    if ( arg[0] == '\0' || !str_prefix( arg, "read" ) )
    {
        bool fAll;

        if ( !str_cmp( argument, "all" ) )
        {
            fAll = TRUE;
            anum = 0;
        }

        else if ( argument[0] == '\0' || !str_prefix(argument, "next"))
        /* read next unread note */
        {
            vnum = 0;
	    sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
	    res	= one_query_res(query);
            while((row=mysql_fetch_row(res)))
            {
                if (!hide_note(ch,row))
                {
                    sprintf( buf, "[%3d] %s: %s\n\r%s\n\rTo: %s\n\r",
                        vnum, row[1], row[4], row[2], row[3]);
                    send_to_char( buf, ch );
                    page_to_char( row[5], ch );
                    update_read(ch,atol(row[6]),atoi(row[0]));
		    mysql_free_result(res);
                    return;
                }
		else if(is_note_to(ch,row[1],row[3]))
		    vnum++;
            }
	    sprintf(buf,"You have no unread %s.\n\r",list_name);
	    send_to_char(buf,ch);
	    mysql_free_result(res);
            return;
        }

        else if ( is_number( argument ) )
        {
            fAll = FALSE;
            anum = atoi( argument );
        }
        else
        {
            send_to_char( "Read which number?\n\r", ch );
            return;
        }

        vnum = 0;
	sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
	res	= one_query_res(query);
        while((row=mysql_fetch_row(res)))
        {
            if (is_note_to(ch,row[1],row[3]) && (vnum++ == anum))
            {
                sprintf( buf, "[%3d] %s: %s\n\r%s\n\rTo: %s\n\r",
                        anum, row[1], row[4], row[2], row[3]);
                send_to_char( buf, ch );
                page_to_char( row[5], ch );
		update_read(ch,atol(row[6]),atoi(row[0]));
		mysql_free_result(res);
                return;
            }
        }

	sprintf(buf,"There aren't that many %s.\n\r",list_name);
	send_to_char(buf,ch);
	mysql_free_result(res);
        return;
    }

    if ( !str_prefix( arg, "list" ) )
    {
	vnum = 0;
	sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
	res	= one_query_res(query);

        while((row=mysql_fetch_row(res)))
	{
	    if (is_note_to(ch,row[1],row[3]))
	    {
		sprintf( buf, "[%3d%s] %s: %s\n\r",
		    vnum, hide_note(ch,row) ? " " : "N",
		    row[1], row[4]);
		send_to_char( buf, ch );
		vnum++;
	    }
	}
	if (!vnum)
	{
	    switch(type)
	    {
		case NOTE_NOTE:	
		    send_to_char("There are no notes for you.\n\r",ch);
		    break;
		case NOTE_IDEA:
		    send_to_char("There are no ideas for you.\n\r",ch);
		    break;
		case NOTE_PENALTY:
		    send_to_char("There are no penalties for you.\n\r",ch);
		    break;
		case NOTE_NEWS:
		    send_to_char("There is no news for you.\n\r",ch);
		    break;
		case NOTE_CHANGES:
		    send_to_char("There are no changes for you.\n\r",ch);
		    break;
	    }
	}
	mysql_free_result(res);
	return;
    }

    if ( !str_prefix( arg, "remove" ) )
    {
        if ( !is_number( argument ) )
            return send_to_char( "Note remove which number?\n\r", ch );


        anum = atoi( argument );
        vnum = 0;
	sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
	res	= one_query_res(query);
        while((row=mysql_fetch_row(res)))
	{
            if (!str_cmp(ch->true_name, row[1]) && vnum++ == anum )
            {
                sprintf(query,"DELETE FROM notes WHERE timestamp=%s AND sender=\"%s\"", row[6], row[1]);
		one_query(query);
                send_to_char( "Ok.\n\r", ch );
		mysql_free_result(res);
                return;
            }
        }

	send_to_char("You must provide the number of a note you have written to remove.\n\r",ch);
	mysql_free_result(res);
        return;
    }

    if ( !str_prefix( arg, "delete" ) && get_trust(ch) >= MAX_LEVEL - 2)
    {
        if ( !is_number( argument ) )
            return send_to_char( "Note delete which number?\n\r", ch );

        anum = atoi( argument );
        vnum = 0;
        sprintf(query,"SELECT * FROM notes WHERE type=%d ORDER BY timestamp ASC",type);
	res	= one_query_res(query);
        while((row=mysql_fetch_row(res)))
	{
            if ( is_note_to( ch,row[1],row[3] ) && vnum++ == anum )
            {
                sprintf(query,"DELETE FROM notes WHERE timestamp=%s AND sender=\"%s\"", row[6], row[1]);
		one_query(query);
		send_to_char("Ok.\n\r",ch);
		mysql_free_result(res);
		return;
            }
        }

 	sprintf(buf,"There aren't that many %s.\n\r",list_name);
	send_to_char(buf,ch);
	mysql_free_result(res);
        return;
    }

    /* below this point only certain people can edit notes */
    if ((type == NOTE_NEWS && !IS_TRUSTED(ch,ANGEL))
    ||  (type == NOTE_CHANGES && !IS_TRUSTED(ch,CREATOR)))
    {
	sprintf(buf,"You aren't high enough level to write %s.",list_name);
	send_to_char(buf,ch);
	return;
    }

    if ( !str_cmp( arg, "+" ) )
    {
	note_attach( ch,type );
	if (ch->pnote->type != type)
	    return send_to_char("You already have a different note in progress.\n\r",ch);

	if (strlen(ch->pnote->text)+strlen(argument) >= 4096)
	    return send_to_char( "Note too long.\n\r", ch );

 	buffer = new_buf();

	add_buf(buffer,ch->pnote->text);
	add_buf(buffer,argument);
	add_buf(buffer,"\n\r");
	free_pstring( ch->pnote->text );
	ch->pnote->text = palloc_string( buf_string(buffer) );
	free_buf(buffer);
	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if (!str_cmp(arg,"-"))
    {
 	int len;
	bool found = FALSE;

	note_attach(ch,type);
        if (ch->pnote->type != type)
            return send_to_char("You already have a different note in progress.\n\r",ch);

	if (ch->pnote->text == NULL || ch->pnote->text[0] == '\0')
	    return send_to_char("No lines left to remove.\n\r",ch);

	strcpy(buf,ch->pnote->text);

	for (len = strlen(buf); len > 0; len--)
 	{
	    if (buf[len] == '\r')
	    {
		if (!found)  /* back it up */
		{
		    if (len > 0)
			len--;
		    found = TRUE;
		}
		else /* found the second one */
		{
		    buf[len + 1] = '\0';
		    free_pstring(ch->pnote->text);
		    ch->pnote->text = palloc_string(buf);
		    return;
		}
	    }
	}
	buf[0] = '\0';
	free_pstring(ch->pnote->text);
	ch->pnote->text = palloc_string(buf);
	return;
    }

    if ( !str_prefix( arg, "subject" ) )
    {
	note_attach( ch,type );
        if (ch->pnote->type != type)
            return send_to_char("You already have a different note in progress.\n\r",ch);

	free_pstring( ch->pnote->subject );
	ch->pnote->subject = palloc_string( argument );
	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_prefix( arg, "to" ) )
    {
	note_attach( ch,type );
        if (ch->pnote->type != type)
            return send_to_char("You already have a different note in progress.\n\r",ch);

	if (is_name("all", argument)
	&& !IS_IMMORTAL(ch)
	&& !IS_HEROIMM(ch)
	&& !(ch->pcdata->induct == CABAL_LEADER))
		return	send_to_char("Sorry, you can't do that!\n\r",ch);
	if (is_number(argument) && !IS_IMMORTAL(ch))
		return send_to_char("You can't do that.\n\r",ch);	
	free_pstring( ch->pnote->to_list );
	ch->pnote->to_list = palloc_string( argument );
	send_to_char( "Ok.\n\r", ch );
	return;
	}

    if ( !str_prefix( arg, "clear" ) )
    {
	if ( ch->pnote != NULL )
	{
	    free_note(ch->pnote);
	    ch->pnote = NULL;
	}

	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_prefix( arg, "show" ) )
    {
	if ( ch->pnote == NULL )
	    return send_to_char( "You have no note in progress.\n\r", ch );

	if (ch->pnote->type != type)
	    return send_to_char("You aren't working on that kind of note.\n\r",ch);

	sprintf( buf, "%s: %s\n\rTo: %s\n\r",
	    ch->pnote->sender,
	    ch->pnote->subject,
	    ch->pnote->to_list
	    );
	send_to_char( buf, ch );
	send_to_char( ch->pnote->text, ch );
	return;
    }

    if ( !str_prefix( arg, "post" ) || !str_prefix(arg, "send"))
    {
	char *strtime;

	if ( ch->pnote == NULL )
	    return send_to_char( "You have no note in progress.\n\r", ch );

        if (ch->pnote->type != type)
            return send_to_char("You aren't working on that kind of note.\n\r",ch);

	if (!str_cmp(ch->pnote->to_list,""))
	    return send_to_char("You need to provide a recipient (name, all, or immortal).\n\r", ch);

	if (!str_cmp(ch->pnote->subject,""))
	    return send_to_char("You need to provide a subject.\n\r",ch);
	if (is_affected_prof(ch, "note_written") && !IS_IMMORTAL(ch))
	    return send_to_char("You have written a note too recently.\n\r",ch);
	ch->pnote->next			= NULL;
	strtime				= ctime( &current_time );
	strtime[strlen(strtime)-1]	= '\0';
	ch->pnote->date			= palloc_string( strtime );
	ch->pnote->date_stamp		= current_time;

	append_note(ch->pnote);
	ch->pnote = NULL;
	send_to_char("Note sent.\n\r",ch);
	add_prof_affect(ch, "note_written", 4, TRUE);
	return;
    }

    send_to_char( "You can't do that.\n\r", ch );
    return;
}
Exemple #8
0
void load_thread(char *name, NOTE_DATA **list, int type, time_t free_time)
{
    FILE *fp;
    NOTE_DATA *pnotelast;

    if ( ( fp = fopen( name, "r" ) ) == NULL )
	return;

    pnotelast = NULL;
    for ( ; ; )
    {
	NOTE_DATA *pnote;
	char letter;

	do
	{
	    letter = getc( fp );
            if ( feof(fp) )
            {
                fclose( fp );
                return;
            }
        }
        while ( isspace(letter) );
        ungetc( letter, fp );

        CREATE( pnote, NOTE_DATA, 1 );

        if ( str_cmp( fread_word( fp ), "sender" ) )
            break;
        pnote->sender   = fread_string( fp );

        if ( str_cmp( fread_word( fp ), "date" ) )
            break;
        pnote->date     = fread_string( fp );

        if ( str_cmp( fread_word( fp ), "stamp" ) )
            break;
        pnote->date_stamp = fread_number(fp);

        if ( str_cmp( fread_word( fp ), "to" ) )
            break;
        pnote->to_list  = fread_string( fp );

        if ( str_cmp( fread_word( fp ), "subject" ) )
            break;
        pnote->subject  = fread_string( fp );

        if ( str_cmp( fread_word( fp ), "text" ) )
            break;
        pnote->text     = fread_string( fp );

        if (free_time && pnote->date_stamp < current_time - free_time)
        {
	    free_note(pnote);
            continue;
        }

	pnote->type = type;

        if (*list == NULL)
            *list           = pnote;
        else
            pnotelast->next     = pnote;

        pnotelast       = pnote;
    }

    strcpy( strArea, NOTE_FILE );
    fpArea = fp;
    bug( "Load_notes: bad key word.", 0 );
    exit( 1 );
    return;
}
Exemple #9
0
/*
 * Snarf a board.
 */
void load_board( BOARD_DATA *board )
{
    FILE      *fp;
    FILE      *fpArch;
    NOTE_DATA *pnotelast;
    char       strsave	[ MAX_INPUT_LENGTH ];

    sprintf( strsave, "%s%s", NOTE_DIR, board->short_name );

    if ( !( fp = fopen( strsave, "r" ) ) )
	return;	    
    	    
    pnotelast = NULL;
    for ( ; ; )
    {
	NOTE_DATA *pnote;
	int        letter;
	int        stat;

	do
	{
	    letter = getc( fp );
	    if ( feof( fp ) )
	    {
		fclose( fp );
		return;
	    }
	}
	while ( isspace( letter ) );
	ungetc( letter, fp );

	pnote		  = (NOTE_DATA *) alloc_mem( sizeof( *pnote ) );

	if ( str_cmp( fread_word( fp, &stat ), "sender" ) )
	    break;
	pnote->sender     = fread_string( fp, &stat );

	if ( str_cmp( fread_word( fp, &stat ), "date" ) )
	    break;
	pnote->date       = fread_string( fp, &stat );

	if ( str_cmp( fread_word( fp, &stat ), "stamp" ) )
	    break;
	pnote->date_stamp = fread_number( fp, &stat );

	if ( str_cmp( fread_word( fp, &stat ), "expire" ) )
	    break;
	pnote->expire     = fread_number( fp, &stat );

	if ( str_cmp( fread_word( fp, &stat ), "to" ) )
	    break;
	pnote->to_list    = fread_string( fp, &stat );

	if ( str_cmp( fread_word( fp, &stat ), "subject" ) )
	    break;
	pnote->subject    = fread_string( fp, &stat );

	if ( str_cmp( fread_word( fp, &stat ), "text" ) )
	    break;
	pnote->text       = fread_string( fp, &stat );

	pnote->next = NULL;


        /*
	 * Should this note be archived right now?
	 */
        if ( pnote->expire < current_time )
        {
	    sprintf( strsave, "%s%s.old", NOTE_DIR, board->short_name );

	    if ( !( fpArch = fopen( strsave, "a" ) ) )
		bug( "Load_board: couldn't open arch boards for writing.", 0 );
	    else
	    {
		append_note( fpArch, pnote );
		fclose( fpArch );
	    }

	    free_note( pnote );
	    board->changed = TRUE;
	    continue;
        }

        if ( !board->note_first )
	    board->note_first	= pnote;
	else
	    pnotelast->next	= pnote;

        pnotelast		= pnote;
    }

    strcpy( strArea, board->short_name );
    fpArea = fp;

    bug( "Load_board: bad key word.", 0 );
    return;
}
Exemple #10
0
/* Start writing a note */
static void do_nwrite (CHAR_DATA *ch, char *argument)
{
	char *strtime;
	char buf[200];
	
	if (IS_NPC(ch)) /* NPC cannot post notes */
		return;

        //if ((get_age(ch) - 17) < 2)
        //{
        //  send_to_char("Newbies cannot write notes.\n\r",ch);
        //  return;
       // }
        if (has_timer(ch)) return;
        if (IS_SET(ch->act, PLR_SILENCE) )
        {
          send_to_char("You are not allowed to write notes.\n\r",ch);
          return;
        }

	if (ch->pcdata->board == NULL) {
	send_to_char("You're not on a board.\n\r", ch );
	return;}

	if (get_trust(ch) < ch->pcdata->board->write_level)
	{
		send_to_char ("You cannot post notes on this board.\n\r",ch);
		return;
	}
	
        if (ch->position != POS_STANDING)
        {
          send_to_char("You can only write notes while standing.\n\r", ch);
          return;
        }
	
	/* continue previous note, if any text was written*/ 
	if (ch->pcdata->in_progress && (!ch->pcdata->in_progress->text))
	{
		send_to_char ("Note in progress cancelled because you did not manage to write any text \n\r"
		              "before losing link.\n\r\n\r",ch);
		free_note (ch->pcdata->in_progress);		              
		ch->pcdata->in_progress = NULL;
	}
	
	
	if (!ch->pcdata->in_progress)
	{
		ch->pcdata->in_progress = new_note();
		ch->pcdata->in_progress->sender = str_dup (ch->pcdata->switchname);

		/* convert to ascii. ctime returns a string which last character is \n, so remove that */	
		strtime = ctime (&current_time);
		strtime[strlen(strtime)-1] = '\0';
	
		ch->pcdata->in_progress->date = str_dup (strtime);
	}

  SET_BIT(ch->extra, EXTRA_AFK);
        if (ch->master) stop_follower(ch, FALSE);    
	act (BOLD GREEN "$n starts writing a note." NO_COLOR , ch, NULL, NULL, TO_ROOM);
	
	/* Begin writing the note ! */
	xprintf (buf, "You are now %s a new note on the " BOLD "%s" NO_COLOR " board.\n\r"
	              "If you are using tintin, type #verbose to turn off alias expansion!\n\r\n\r",
	               ch->pcdata->in_progress->text ? "continuing" : "posting",
	               ch->pcdata->board->short_name);
	send_to_char (buf,ch);
	
	xprintf (buf, BOLD YELLOW "From" NO_COLOR ":    %s\n\r\n\r", ch->pcdata->switchname);
	send_to_char (buf,ch);

	if (!ch->pcdata->in_progress->text) /* Are we continuing an old note or not? */
	{
		switch (ch->pcdata->board->force_type)
		{
		case DEF_NORMAL:
			xprintf (buf, "If you press Return, default recipient \"" BOLD "%s" NO_COLOR "\" will be chosen.\n\r",
					  ch->pcdata->board->names);
			break;
		case DEF_INCLUDE:
			xprintf (buf, "The recipient list MUST include \"" BOLD "%s" NO_COLOR "\". If not, it will be added automatically.\n\r",
						   ch->pcdata->board->names);
			break;
	
		case DEF_EXCLUDE:
			xprintf (buf, "The recipient of this note must NOT include: \"" BOLD "%s" NO_COLOR "\".",
						   ch->pcdata->board->names);
	
			break;
		}			
		
		send_to_char (buf,ch);
		send_to_char ("\n\r" BOLD YELLOW "To" NO_COLOR ":      ",ch);
	
		ch->desc->connected = CON_NOTE_TO;
		/* nanny takes over from here */
		
	}
	else /* we are continuing, print out all the fields and the note so far*/
	{
		xprintf (buf, BOLD YELLOW "To" NO_COLOR ":      %s\n\r"
		              BOLD YELLOW "Expires" NO_COLOR ": %s\n\r"
		              BOLD YELLOW "Subject" NO_COLOR ": %s\n\r", 
		               ch->pcdata->in_progress->to_list,
		               ctime(&ch->pcdata->in_progress->expire),
		               ch->pcdata->in_progress->subject);
		send_to_char (buf,ch);
		send_to_char (BOLD GREEN "Your note so far:\n\r" NO_COLOR,ch);
		if (ch->pcdata->in_progress != NULL)
		send_to_char (ch->pcdata->in_progress->text,ch);
		
		send_to_char ("\n\rEnter text. Type " BOLD "~" NO_COLOR " or " BOLD "END" NO_COLOR " on an empty line to end note.\n\r"
		                    "=======================================================\n\r",ch);
		

		ch->desc->connected = CON_NOTE_TEXT;		            

	}
	
}
Exemple #11
0
/* Load a single board */
static void load_board (BOARD_DATA *board)
{
	FILE *fp, *fp_archive;
	NOTE_DATA *last_note;
	char filename[200];
	
	xprintf (filename, "%s%s", NOTE_DIR, board->short_name);
	
	fp = fopen (filename, "r");
	
	/* Silently return */
	if (!fp)
		return;		
		
	/* Start note fetching. copy of db.c:load_notes() */

    last_note = NULL;

    for ( ; ; )
    {
        NOTE_DATA *pnote;
        char letter;

        do
        {
            letter = getc( fp );
            if ( feof(fp) )
            {
                fclose( fp );
                return;
            }
        }
        while ( isspace(letter) );
        ungetc( letter, fp );

        pnote             = alloc_perm( sizeof(*pnote) );

        if ( str_cmp( fread_word( fp ), "sender" ) )
            break;
        pnote->sender     = fread_string( fp );

        if ( str_cmp( fread_word( fp ), "date" ) )
            break;
        pnote->date       = fread_string( fp );

        if ( str_cmp( fread_word( fp ), "stamp" ) )
            break;
        pnote->date_stamp = fread_number( fp );

        if ( str_cmp( fread_word( fp ), "expire" ) )
            break;
        pnote->expire = fread_number( fp );

        if ( str_cmp( fread_word( fp ), "to" ) )
            break;
        pnote->to_list    = fread_string( fp );

        if ( str_cmp( fread_word( fp ), "subject" ) )
            break;
        pnote->subject    = fread_string( fp );

        if ( str_cmp( fread_word( fp ), "text" ) )
            break;
        pnote->text       = fread_string( fp );
        
        pnote->next = NULL; /* jic */
        
        /* Should this note be archived right now ? */
        
        if (pnote->expire < current_time)
        {
			char archive_name[200];

			xprintf (archive_name, "%s%s.old", NOTE_DIR, board->short_name);
			fp_archive = fopen (archive_name, "a");
			if (!fp_archive)
				bug ("Could not open archive boards for writing",0);
			else
			{
				append_note (fp_archive, pnote);
				fclose (fp_archive); /* it might be more efficient to close this later */
			}

			free_note (pnote);
			board->changed = TRUE;
			continue;
			
        }
        

        if ( board->note_first == NULL )
            board->note_first = pnote;
        else
            last_note->next     = pnote;

        last_note         = pnote;
    }

    bug( "Load_notes: bad key word.", 0 );
    return; /* just return */
}
Exemple #12
0
void handle_con_note_text (DESCRIPTOR_DATA *d, char * argument)
{
	CHAR_DATA *ch = d->character;
	char buf[MAX_STRING_LENGTH];
	char letter[4*MAX_STRING_LENGTH];
	
	if (!ch->pcdata->in_progress)
	{
		d->connected = CON_PLAYING;
		bug ("nanny: In CON_NOTE_TEXT, but no note in progress",0);
		return;
	}

	/* First, check for EndOfNote marker */

	strcpy (buf, argument);
	if ((!str_cmp(buf, "~")) || (!str_cmp(buf, "END")))
	{
		write_to_buffer (d, "\n\r\n\r",0);
		write_to_buffer (d, szFinishPrompt, 0);
		write_to_buffer (d, "\n\r", 0);
		d->connected = CON_NOTE_FINISH;
		return;
	}
  else if (!str_cmp(buf, "~delete"))
  {
    delete_last_line_in_note(ch);
    return;
  }
	
	smash_tilde (buf); /* smash it now */

	/* Check for too long lines. Do not allow lines longer than 80 chars */
	
	if (strlen(buf) > MAX_LINE_LENGTH)
	{
		write_to_buffer (d, "Too long line rejected. Do NOT go over 80 characters!\n\r",0);
		return;
	}
	
	/* Not end of note. Copy current text into temp buffer, add new line, and copy back */

	/* How would the system react to strcpy( , NULL) ? */		
	if (ch->pcdata->in_progress->text != NULL)
	{
		strcpy (letter, ch->pcdata->in_progress->text);
		free_string (ch->pcdata->in_progress->text);
		ch->pcdata->in_progress->text = NULL; /* be sure we don't free it twice */
	}
	else
		strcpy (letter, "");
		
	/* Check for overflow */
	
	if ((strlen2(letter) + strlen2(buf)) > MAX_NOTE_TEXT)
	{ /* Note too long, take appropriate steps */
		write_to_buffer (d, "Note too long!\n\r", 0);
		free_note (ch->pcdata->in_progress);
		ch->pcdata->in_progress = NULL;			/* important */
		d->connected = CON_PLAYING;
		return;			
	}
	
	/* Add new line to the buffer */
	
	strcat (letter, buf);
	strcat (letter, "\r\n"); /* new line. \r first to make note files better readable */

	/* allocate dynamically */		
	ch->pcdata->in_progress->text = str_dup (letter);
}
Exemple #13
0
void note_remove( CHAR_DATA *ch, NOTE_DATA *pnote, bool idelete)
{
	char to_new[MAX_INPUT_LENGTH];
	char to_one[MAX_INPUT_LENGTH];
	NOTE_DATA *prev;
	NOTE_DATA **list;
	char *to_list;

	if (!idelete)
	{
	/* make a new list */
		to_new[0]	= '\0';
		to_list	= pnote->to_list;
		while ( *to_list != '\0' )
		{
			to_list	= one_argument( to_list, to_one );
			if ( to_one[0] != '\0' && str_cmp( ch->name, to_one ) )
		{
			strcat( to_new, " " );
			strcat( to_new, to_one );
		}
		}
		/* Just a simple recipient removal? */
	   if ( str_cmp( ch->name, pnote->sender ) && to_new[0] != '\0' )
	   {
	   PURGE_DATA( pnote->to_list );
	   pnote->to_list = str_dup( to_new + 1 );
	   return;
	   }
	}
	/* nuke the whole note */

	switch(pnote->type)
	{
	default:
		return;
	case NOTE_NOTE:
		list = &note_list;
		break;
	case NOTE_IDEA:
		list = &idea_list;
		break;
	case NOTE_PENALTY:
		list = &penalty_list;
		break;
	case NOTE_NEWS:
		list = &news_list;
		break;
	case NOTE_CHANGES:
		list = &changes_list;
		break;
	}

	/*
	 * Remove note from linked list.
	 */
	if ( pnote == *list )
	{
	*list = pnote->next;
	}
	else
	{
	for ( prev = *list; prev != NULL; prev = prev->next )
	{
		if ( prev->next == pnote )
		break;
	}

	if ( prev == NULL )
	{
		bug( "Note_remove: pnote not found.", 0 );
		return;
	}

	prev->next = pnote->next;
	}

	save_notes(pnote->type);
	free_note(pnote);
	return;
}
void do_project( CHAR_DATA *ch, char *argument )
{
   char arg[MAX_INPUT_LENGTH];
   char arg1[MAX_INPUT_LENGTH];
   char arg2[MAX_INPUT_LENGTH];
   char buf[MSL];
   int pcount;
   int pnum;
   PROJECT_DATA *pproject;

   if( IS_NPC( ch ) )
      return;

   if( !ch->desc )
   {
      bug( "do_project: no descriptor", 0 );
      return;
   }

   argument = one_argument( argument, arg );
   smash_tilde( argument );

   if( !str_cmp( arg, "save" ) )
   {
      write_projects();
      send_to_char ("Projects saved.\n\r",ch);
      return;
   }

   if ( !str_cmp( arg, "code" ) )
   {
      pcount = 0;
	send_to_char( 
" ## | Owner       | Project              |\n\r",ch);
	send_to_char(
"---|-------------|----------------------|--------------------------|-----------\n\r",ch);
      for( pproject = first_project; pproject; pproject = pproject->next )
      {
	 pcount++;
 	if ( (pproject->status && str_cmp(pproject->status, "approved"))
		 || pproject->coder != NULL)  
		continue;
	xprintf(buf, "%2d | %-11s | %-20s |\n\r", 
	    pcount, 
	    pproject->owner ? pproject->owner : "(None)", 
 	    pproject->name);
        send_to_char(buf, ch);
      }
	return;
   }
   if ( !str_cmp( arg, "more" ) || !str_cmp( arg, "mine" ) )
   {
        NOTE_DATA *log;
	bool MINE = FALSE;
	int num_logs=0;
	pcount = 0;
	
	if ( !str_cmp( arg, "mine" ) )
		MINE = TRUE;

	send_to_char("\n\r",ch);
	send_to_char( 
" ## | Owner       | Project              | Coder         | Status     | # of Logs\n\r",ch);
	send_to_char(
"---|-------------|----------------------|---------------|------------|----------\n\r", ch);
      for( pproject = first_project; pproject; pproject = pproject->next )
      {
	   pcount++;
	   if ( MINE &&(!pproject->owner||str_cmp( ch->name,pproject->owner)) 
		&& (!pproject->coder || str_cmp( ch->name, pproject->coder)) )
		continue;
	   else if (!MINE && pproject->status && 
			!str_cmp("Done", pproject->status ) )
		continue;
	   num_logs = 0;
	   for ( log = pproject->first_log; log; log=log->next )
		num_logs++;
	   xprintf(buf, "%2d | %-11s | %-20s | %-13s | %-10s | %3d\n\r", 
	    pcount, 
	    pproject->owner ? pproject->owner : "(None)", 
 	    pproject->name,
	    pproject->coder ? pproject->coder : "(None)",
	    pproject->status ? pproject->status : "(None)",
	     num_logs);
	   send_to_char(buf, ch);
       }
	return;
   }
   if( arg[0] == '\0' || !str_cmp( arg, "list" ) )
   {
      bool aflag, projects_available;
      aflag = FALSE;
      projects_available = FALSE;
      if( !str_cmp( argument, "available" ) )
      	aflag = TRUE;

      send_to_char("\n\r",ch);
      if( !aflag )
      {
	send_to_char( 
" ## | Owner       | Project              | Date                     | Status\n\r",ch);
	send_to_char(
"---|-------------|----------------------|--------------------------|-----------\n\r",ch);
      }
      else
      {
	send_to_char(" ## | Project              | Date\n\r",ch);
	send_to_char(
"---|----------------------|--------------------------\n\r",ch);
      }
      pcount = 0;
      for( pproject = first_project; pproject; pproject = pproject->next )
      {
	 pcount++;
	 if (pproject->status && !str_cmp("Done", pproject->status ) )
		continue;
 	 if(!aflag)
	   xprintf(buf, "%2d | %-11s | %-20s | %-24s | %-10s\n\r", 
	    pcount, 
	    pproject->owner ? pproject->owner : "(None)", 
 	    pproject->name,
	    pproject->date,
	    pproject->status ? pproject->status : "(None)");
	 else
	   if( !pproject->taken )
	   {
	      if( !projects_available )
		projects_available = TRUE;
	      xprintf(buf, "%2d | %-20s | %s\n\r",
	      pcount,
	      pproject->name,
	      pproject->date);
	   }
	   send_to_char(buf, ch);
      }
      if(pcount == 0)
         send_to_char("No projects exist.\n\r",ch);
      else if( aflag && !projects_available )
	 send_to_char("No projects available.\n\r",ch); 
      return;
   }

   if( !str_cmp( arg, "add" ) )
   {
      char *strtime;
      PROJECT_DATA *new_project; /* Just to be safe */

      if( get_trust(ch) < LEVEL_JUDGE)
      {
	send_to_char("You are not powerfull enough to add a new project.\n\r",ch);
	return;
      }

      new_project = alloc_mem( sizeof( PROJECT_DATA));	
      LINK( new_project, first_project, last_project, next, prev );
      new_project->name = str_dup(argument);
      new_project->coder = NULL;
      new_project->taken = FALSE;
      new_project->owner = NULL;
      new_project->status = NULL;
      new_project->description = str_dup( "" );
      new_project->first_log = NULL;
      new_project->last_log = NULL;
      strtime                         = ctime( &current_time );
      strtime[strlen(strtime)-1]      = '\0'; 
      new_project->date = str_dup( strtime );
      write_projects();
      send_to_char("Ok.\n\r",ch );
      return;
   }

   if( !is_number( arg ) )   
   {
      send_to_char("Invalid project.\n\r",ch);
      return;
   }
      
   pnum = atoi( arg );
   pproject = get_project_by_number( pnum );
   if(!pproject)
   {
      send_to_char("No such project.\n\r",ch);
      return;
   }

   argument = one_argument( argument, arg1 );

   if( !str_cmp( arg1, "desc" ) )
   {
      if ( pproject->description == NULL )
	pproject->description = str_dup("");
      string_append( ch, &pproject->description );
      return;
   }
   if( !str_cmp( arg1, "delete" ) )
   {
      NOTE_DATA *log, *tlog;
      if( get_trust(ch) < LEVEL_HIGHJUDGE)
      {
	send_to_char("You are not high enough level to delete a project.\n\r",
		ch );
        return;
      }

      tlog = NULL;
      for( log = pproject->first_log; log; tlog = log, log = log->next )
      {
          if ( tlog == NULL )
               pproject->first_log   = log->next;
          else
               tlog->next = log->next;
          free_note( log );
      }
      pproject->last_log = NULL;
      UNLINK( pproject, first_project, last_project, next, prev );

      free_string( pproject->name );
      if ( pproject->coder )
	free_string( pproject->coder );
      if( pproject->owner )
	free_string( pproject->owner );
      if( pproject->description )
        free_string( pproject->description );
      if ( pproject->date )
	free_string( pproject->date );
      if ( pproject->status )
	free_string( pproject->status );

      free_mem( pproject, sizeof( *pproject) );
      write_projects();
      send_to_char("Ok.\n\r",ch );
      return;
   }

   if( !str_cmp( arg1, "take" ) )
   {
      if( pproject->taken  && pproject->owner &&
		!str_cmp(pproject->owner, ch->name ) )
      {
	pproject->taken = FALSE;
	free_string( pproject->owner );
	pproject->owner = NULL;
	send_to_char("You removed yourself as the owner.\n\r", ch );
        write_projects();
	return;
      }
      else if ( pproject->taken )
      {
      	send_to_char("This project is already taken.\n\r" ,ch);
	return;
      }


      if( pproject->owner )
	free_string( pproject->owner );
      pproject->owner = str_dup( ch->name );
      pproject->taken = TRUE;
      write_projects();
      send_to_char("Ok.\n\r" ,ch);
      return;
   }
   if( !str_cmp( arg1, "coder" ) )
   {
	if ( pproject->coder && !str_cmp(ch->name, pproject->coder))
	{
	  free_string( pproject->coder );
	  pproject->coder = NULL;
	  send_to_char("You removed yourself as the coder.\n\r", ch );
      	  write_projects();
	  return;
	}
	else if ( pproject->coder )
	{
	  send_to_char("This project already has a coder.\n\r",ch );
	  return;
	}
       	pproject->coder = str_dup( ch->name );
	write_projects();
	send_to_char("Ok.\n\r" ,ch);
	return;
   }
   if( !str_cmp( arg1, "status" ) )
   {
      if( pproject->owner && str_cmp( pproject->owner, ch->name ) 
	&& get_trust(ch) < LEVEL_JUDGE
	&& pproject->coder 
	&& str_cmp(pproject->coder, ch->name) )
      {  
	send_to_char("This is not your project!\n\r",ch );
	return;
      }
      if(pproject->status)
	free_string(pproject->status);
      pproject->status = str_dup(argument);
      write_projects();
      send_to_char("Done.\n\r", ch );
      return;
   } 
   if( !str_cmp( arg1, "show" ) )
   {
	if ( pproject->description )
	  send_to_char ( pproject->description, ch );
	else
	  send_to_char ("That project does not have a description.\n\r",ch);
	return;
   }
   if( !str_cmp( arg1, "log" ) )
   {
      NOTE_DATA *plog,*tlog;
      if( !str_cmp( argument, "write" ) )
      {
	 string_append( ch, &ch->pnote->text);
	 return;
      }

      argument = one_argument( argument, arg2 );

      if( !str_cmp( arg2, "subject" ) )
      {
	note_attach(ch);
	free_string(ch->pnote->subject);
	ch->pnote->subject = str_dup( argument );
	send_to_char("Ok.\n\r",ch);
	return;
      }

      if( !str_cmp( arg2, "post" ) )
      {
        char *strtime;

        if( pproject->owner && str_cmp(ch->name, pproject->owner) &&
	    pproject->coder && str_cmp(ch->name, pproject->coder) && 
	    get_trust(ch) < LEVEL_JUDGE )
	{
	   send_to_char("This is not your project!\n\r",ch );
	   return;
	}

        if ( !ch->pnote )
        {   
            send_to_char("You have no log in progress.\n\r" ,ch);
            return;
        }

        if ( !ch->pnote->subject )
	{
	    send_to_char( "Your log has no subject.\n\r",ch );
	    return;
	}
        
        strtime                         = ctime( &current_time );
        strtime[strlen(strtime)-1]      = '\0'; 
        ch->pnote->date                 = str_dup( strtime );
	ch->pnote->sender		= ch->name;
        
        plog           = ch->pnote;
        ch->pnote       = NULL;
	if( !pproject->first_log )       
	    pproject->first_log = plog;
	else
	{
	    for( tlog = pproject->first_log; tlog->next; tlog = tlog->next )
	    	;
	    tlog->next = plog;
	}

	plog->next = NULL;
	pproject->last_log = plog;
	write_projects();
        send_to_char("Ok.\n\r",ch);
	return;
      }
      
      if( !str_cmp( arg2, "list" ) )
      {
        if( pproject->owner && pproject->coder 
	    && str_cmp(ch->name, pproject->owner) 
	    && get_trust(ch) < LEVEL_BUILDER
	    && str_cmp(ch->name, pproject->coder) )
	{
	   send_to_char("This is not your project!\n\r",ch );
	   return;
	}

	pcount = 0;
        xprintf(buf, "Project: %-12s: %s\n\r",
         pproject->owner ? pproject->owner : "(None)",
         pproject->name);   
         send_to_char(buf,ch);   	

       	for( plog = pproject->first_log; plog; plog = plog->next )
      	{
           pcount++;
           xprintf( buf, "%2d) %-12s: %s\n\r",
                        pcount,
                        plog->sender,
                        plog->subject );
           send_to_char(buf,ch);
   	}
	if( pcount == 0 )
	   send_to_char("No logs available.\n\r",ch );
	return;
      }
      
      if( !is_number( arg2 ))
      {
	send_to_char("Invalid log.\n\r",ch );
        return;
      }
      
      pnum = atoi( arg2 );

      plog = get_log_by_number( pproject, pnum );	
      if( !plog )
      {
         send_to_char("Invalid log.\n\r",ch );
         return;
      }
	

      if( !str_cmp( argument, "delete" ) )
      {
        if( pproject->owner 
	 && str_cmp(ch->name, pproject->owner) 
	 && get_trust(ch) < LEVEL_JUDGE
         && pproject->coder && str_cmp(ch->name, pproject->coder ) )
	{
	   send_to_char("This is not your project!\n\r",ch );
	   return;
	}
	for( tlog = pproject->first_log; tlog->next; tlog = tlog->next )
		if( tlog->next == plog )
			break;
	tlog->next = plog->next;	
	free_note( plog );
	write_projects();
        send_to_char("Ok.\n\r",ch );
	return;
      }

      if( !str_cmp( argument, "read" ) )
      {
        if( pproject->owner && pproject->coder 
	    && str_cmp(ch->name, pproject->owner) 
	    && get_trust(ch) < LEVEL_BUILDER
	    && str_cmp(ch->name, pproject->coder ) )
	{
	   send_to_char("This is not your project!\n\r" ,ch);
	   return;
	}

	xprintf( buf, "[%3d] %s: %s\n\r%s\n\r%s",
        pnum,
        plog->sender,
        plog->subject,
        plog->date,
        plog->text );
        send_to_char(buf,ch);
	return;
      }
    }
   send_to_char("Unknown syntax see help 'PROJECT'.\n\r", ch );
   return;
}
Exemple #15
0
void parse_sign( CHAR_DATA *ch, char *argument, int type )
{
    BUFFER *buffer;
    char buf[MAX_STRING_LENGTH];
    char arg[MAX_INPUT_LENGTH];
    OBJ_INDEX_DATA *pObjIndex;
    OBJ_DATA *obj;

    if ( IS_NPC(ch) )
	return;

    argument = one_argument( argument, arg );
    smash_tilde( argument );

    if ( arg[0] == '\0' )
    {
        return;
    }

    if ( !str_cmp( arg, "+" ) )
    {
	sign_attach( ch,type );
	if (ch->pnote->type != type)
	{
	    send_to_char(
		"You already have a different note in progress.\n\r",ch);
	    return;
	}

	if (strlen(ch->pnote->text)+strlen(argument) >= 4096)
	{
	    send_to_char( "Sign too long.\n\r", ch );
	    return;
	}

 	buffer = new_buf();

	add_buf(buffer,ch->pnote->text);
	add_buf(buffer,argument);
	add_buf(buffer,"\n\r");
	free_string( ch->pnote->text );
	ch->pnote->text = str_dup( buf_string(buffer) );
	free_buf(buffer);
	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if (!str_cmp(arg,"-"))
    {
 	int len;
	bool found = FALSE;

	sign_attach(ch,type);
        if (ch->pnote->type != type)
        {
            send_to_char(
                "You already have a different note in progress.\n\r",ch);
            return;
        }

	if (ch->pnote->text == NULL || ch->pnote->text[0] == '\0')
	{
	    send_to_char("No lines left to remove.\n\r",ch);
	    return;
	}

	strcpy(buf,ch->pnote->text);

	for (len = strlen(buf); len > 0; len--)
 	{
	    if (buf[len] == '\r')
	    {
		if (!found)  /* back it up */
		{
		    if (len > 0)
			len--;
		    found = TRUE;
		}
		else /* found the second one */
		{
		    buf[len + 1] = '\0';
		    free_string(ch->pnote->text);
		    ch->pnote->text = str_dup(buf);
		    return;
		}
	    }
	}
	buf[0] = '\0';
	free_string(ch->pnote->text);
	ch->pnote->text = str_dup(buf);
	return;
    }

    if ( !str_prefix( arg, "make" ) )
    {
	sign_attach( ch,type );
        if (ch->pnote->type != type)
        {
            send_to_char(
                "You already have a different note in progress.\n\r",ch);
            return;
        }
	free_string( ch->pnote->to_list );
	free_string( ch->pnote->subject );
	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_prefix( arg, "clear" ) )
    {
	if ( ch->pnote != NULL )
	{
	    free_note(ch->pnote);
	    ch->pnote = NULL;
	}

	send_to_char( "Ok.\n\r", ch );
	return;
    }

    if ( !str_prefix( arg, "show" ) )
    {
	if ( ch->pnote == NULL )
	{
	    send_to_char( "You have no sign in progress.\n\r", ch );
	    return;
	}

	if (ch->pnote->type != type)
	{
	    send_to_char("You aren't working on that kind of note.\n\r",ch);
	    return;
	}

	send_to_char( ch->pnote->text, ch );
	return;
    }

    if ( !str_prefix( arg, "post" ) || !str_prefix(arg, "send")
    || !str_prefix(arg, "save"))
    {
	EXTRA_DESCR_DATA *ed;

	if ( ch->pnote == NULL )
	{
	    send_to_char( "You have no sign in progress.\n\r", ch );
	    return;
	}

        if (ch->pnote->type != type)
        {
            send_to_char("You aren't working on that kind of note.\n\r",ch);
            return;
        }

	pObjIndex = get_obj_index(OBJ_VNUM_QUEST_SIGN);
	obj = create_object( pObjIndex, ch->level );
	obj_to_room( obj, ch->in_room );

	ed = new_extra_descr();

	ed->keyword = str_dup( "sign" );

	buffer = new_buf();
        add_buf(buffer,ch->pnote->text);
	ed->description = str_dup(buf_string(buffer));

	ed->next = NULL;
	obj->extra_descr = ed;
	ch->pnote = NULL;

        send_to_char( "A sign now floats before you.\n\r", ch );
	return;
    }

    send_to_char( "You can't do that.\n\r", ch );
    return;
}