bnchat.c

打魔兽战网的都知道他是什么

		    case mode_chat:
			if (client.text[0]=='\0')
			    break;
			if (client.text[0]=='/')
			{
		            munge(&client);
			}
			else
			{
			    ansi_printf(&client,ansi_text_color_blue,"\r<%s>",user.player);
			    printf(" ");
			    str_print_term(stdout,client.text,0,0);
			    printf("\n");
			    client.munged = 1;
			}
			
			if (!(packet = packet_create(packet_class_bnet)))
			{
			    fprintf(stderr,"%s: could not create packet\n",argv[0]);
			    psock_close(client.sd);
			    if (client.changed_in)
				tcsetattr(client.fd_stdin,TCSAFLUSH,&client.in_attr_old);
			    return STATUS_FAILURE;
			}
			packet_set_size(packet,sizeof(t_client_message));
			packet_set_type(packet,CLIENT_MESSAGE);
			packet_append_string(packet,client.text);
			client_blocksend_packet(client.sd,packet);
			packet_del_ref(packet);
			break;
			
		    default:
			/* one of the wait states; erase what they typed */
		        munge(&client);
			break;
		    }
		    
		    client.commpos = 0;
		    client.text[0] = '\0';
		    break;
		}
	    }
	    
	    if (PSOCK_FD_ISSET(client.sd,&rfds)) /* got network data */
	    {
		/* rpacket is from server, packet is from client */
		switch (net_recv_packet(client.sd,rpacket,&client.currsize))
		{
		case 0: /* nothing */
		    break;
		    
		case 1:
		    switch (packet_get_type(rpacket))
		    {
		    case SERVER_ECHOREQ: /* might as well support it */
			if (packet_get_size(rpacket)<sizeof(t_server_echoreq))
			{
		            munge(&client);
			    printf("Got bad SERVER_ECHOREQ packet (expected %u bytes, got %u)\n",sizeof(t_server_echoreq),packet_get_size(rpacket));
			    break;
			}
			
			if (!(packet = packet_create(packet_class_bnet)))
			{
		            munge(&client);
			    fprintf(stderr,"%s: could not create packet\n",argv[0]);
			    psock_close(client.sd);
			    if (client.changed_in)
				tcsetattr(client.fd_stdin,TCSAFLUSH,&client.in_attr_old);
			    return STATUS_FAILURE;
			}
			packet_set_size(packet,sizeof(t_client_echoreply));
			packet_set_type(packet,CLIENT_ECHOREPLY);
			bn_int_set(&packet->u.client_echoreply.ticks,bn_int_get(rpacket->u.server_echoreq.ticks));
			client_blocksend_packet(client.sd,packet);
			packet_del_ref(packet);
			
			break;
			
		    case SERVER_STARTGAME4_ACK:
			if (client.mode==mode_gamewait)
			{
		            munge(&client);
			    
			    if (bn_int_get(rpacket->u.server_startgame4_ack.reply)==SERVER_STARTGAME4_ACK_OK)
			    {
				printf("Game created.\n");
				client.mode = mode_gamestop;
			    }
			    else
			    {
				printf("Game could not be created, try another name.\n");
				client.mode = mode_gamename;
			    }
			}
			break;

		    case SERVER_W3XP_CLAN_INVITEREQ:
			if (packet_get_size(rpacket)<sizeof(t_server_w3xp_clan_invitereq))
			{
		            munge(&client);
			    printf("Got bad SERVER_W3XP_CLAN_INVITEREQ packet (expected %u bytes, got %u)\n",sizeof(t_server_w3xp_clan_invitereq),packet_get_size(rpacket));
			    break;
			}

			{
			    char const * clan;
			    char const * inviter;
			    int offset;
			    
			    offset = sizeof(t_server_w3xp_clan_invitereq);
			    if (!(clan = packet_get_str_const(rpacket,offset,MAX_CLANNAME_LEN)))
			    {
				munge(&client);
				printf("Got SERVER_W3XP_CLAN_INVITEREQ with bad or missing clanname\n");
				break;
			    }
			    offset+=strlen(clan)+1;
			    if (!(inviter = packet_get_str_const(rpacket,offset,USER_NAME_MAX)))
			    {
				munge(&client);
				printf("Got SERVER_W3XP_CLAN_INVITEREQ with bad or missing inviter\n");
				break;
			    }
			    user.count   = bn_int_get(rpacket->u.server_w3xp_clan_invitereq.count);
			    user.clantag = bn_int_get(rpacket->u.server_w3xp_clan_invitereq.clantag);
			    if (user.inviter)
			    	xfree((void *)user.inviter);
			    user.inviter = xstrdup(inviter);
			    
			    munge(&client);
			    printf("%s invited you to Clan %s\n",inviter,clan);
			    printf("Do you want to accept invitation (yes/no) ? [yes] ");
			    
			    client.mode = mode_claninvite;
			}
			

			
		    case SERVER_W3XP_CLANMEMBERUPDATE:
			if (packet_get_size(rpacket)<sizeof(t_server_w3xp_clanmemberupdate))
			{
		            munge(&client);
			    printf("Got bad SERVER_W3XP_CLANMEMBERUPDATE packet (expected %u bytes, got %u)\n",sizeof(t_server_w3xp_clanmemberupdate),packet_get_size(rpacket));
			    break;
			}

			if (client.mode == mode_claninvite)
			    break;
			
			{
			    char const * member;
			    char rank, online;
			    char const * rank_p;
			    char const * online_p;
			    char const * append_str;
			    int offset;
			    char const * rank_str;
			    char const * online_str;
			    
			    offset = sizeof(t_server_w3xp_clanmemberupdate);
			    if (!(member = packet_get_str_const(rpacket,offset,USER_NAME_MAX)))
			    {
				munge(&client);
				printf("Got SERVER_W3XP_CLANMEMBERUPDATE with bad or missing member\n");
				break;
			    }
			    offset+=strlen(member)+1;
			    if (!(rank_p = (char *)packet_get_data_const(rpacket,offset,1)))
			    {
				munge(&client);
				printf("Got SERVER_W3XP_CLANMEMBERUPDATE with bad or missing rank\n");
				break;
			    }
			    rank = *rank_p;
			    offset+=1;
			    if (!(online_p = (char *)packet_get_data_const(rpacket,offset,1)))
			    {
				munge(&client);
				printf("Got SERVER_W3XP_CLAN_MEMBERUPDATE with bad or missing online status\n");
				break;
			    }
			    online = *online_p;
			    offset+=1;
			    if (!(append_str = packet_get_str_const(rpacket,offset,USER_NAME_MAX)))
			    {
				munge(&client);
				printf("Got SERVER_W3XP_CLANMEMBERUPDATE with bad or missing append_str\n");
				break;
			    }
			    
			    switch (rank)
			    {
				case SERVER_W3XP_CLAN_MEMBER_NEW:
					rank_str = "New clan member";
					break;
				case SERVER_W3XP_CLAN_MEMBER_PEON:
					rank_str = "Peon";
					break;
				case SERVER_W3XP_CLAN_MEMBER_GRUNT:
					rank_str = "Grunt";
					break;
				case SERVER_W3XP_CLAN_MEMBER_SHAMAN:
					rank_str = "Shaman";
					break;
				case SERVER_W3XP_CLAN_MEMBER_CHIEFTAIN:
					rank_str = "Chieftain";
					break;
				default:
					rank_str = "";
					
			    }

			    switch (online)
			    {
				case SERVER_W3XP_CLAN_MEMBER_OFFLINE:
					online_str = "offline";
					break;
				case SERVER_W3XP_CLAN_MEMBER_ONLINE:
					online_str = "online";
					break;
				case SERVER_W3XP_CLAN_MEMBER_CHANNEL:
					online_str = "in channel";
					break;
				case SERVER_W3XP_CLAN_MEMBER_GAME:
					online_str = "in game";
					break;
				case SERVER_W3XP_CLAN_MEMBER_PRIVATE_GAME:
					online_str = "in private game";
					break;
				default:
					online_str = "";
			    }
			    
			    munge(&client);
			    printf("%s %s  is now %s %s\n",rank_str,member,online_str,append_str);
			}
		    
			
		    case SERVER_STATSREPLY:
			if (client.mode==mode_waitstat)
			{
			    unsigned int names,keys;
			    unsigned int match;
			    unsigned int strpos;
			    char const * temp;
			    
		            munge(&client);
			    
			    names = bn_int_get(rpacket->u.server_statsreply.name_count);
			    keys  = bn_int_get(rpacket->u.server_statsreply.key_count);
			    match = bn_int_get(rpacket->u.server_statsreply.requestid);
			    
			    if (names!=1 || keys!=4 || match!=statsmatch)
				printf("mangled reply (name_count=%u key_count=%u unknown1=%u)\n",
				       names,keys,match);
			    
			    strpos = sizeof(t_server_statsreply);
			    if ((temp = packet_get_str_const(rpacket,strpos,256)))
			    {
				printf(" Sex: ");
				ansi_printf(&client,ansi_text_color_yellow,"%s\n",temp);
				strpos += strlen(temp)+1;
			    }
			    if ((temp = packet_get_str_const(rpacket,strpos,256)))
			    {
				printf(" Age: ");
				ansi_printf(&client,ansi_text_color_yellow,"%s\n",temp);
				strpos += strlen(temp)+1;
			    }
			    if ((temp = packet_get_str_const(rpacket,strpos,256)))
			    {
				printf(" Location: ");
				ansi_printf(&client,ansi_text_color_yellow,"%s\n",temp);
				strpos += strlen(temp)+1;
			    }
			    if ((temp = packet_get_str_const(rpacket,strpos,256)))
			    {
				char   msgtemp[1024];
				char * tok;
				
				printf(" Description: \n");
				if (client.useansi)
				    ansi_text_color_fore(ansi_text_color_yellow);
				strncpy(msgtemp,temp,sizeof(msgtemp));
				msgtemp[sizeof(msgtemp)-1] = '\0';
				for (tok=strtok(msgtemp,"\r\n"); tok; tok=strtok(NULL,"\r\n"))
				    printf("  %s\n",tok);
				if (client.useansi)
				    ansi_text_reset();
				strpos += strlen(temp)+1;
			    }
			    
			    if (match==statsmatch)
				client.mode = mode_command;
			}
			break;
			
		    case SERVER_PLAYERINFOREPLY: /* hmm. we didn't ask for one... */
			break;
			
		    case SERVER_MESSAGE:
			if (packet_get_size(rpacket)<sizeof(t_server_message))
			{
		            munge(&client);
			    printf("Got bad SERVER_MESSAGE packet (expected %u bytes, got %u)",sizeof(t_server_message),packet_get_size(rpacket));
			    break;
			}
			
			{
			    char const * speaker;
			    char const * message;
			    
			    if (!(speaker = packet_get_str_const(rpacket,sizeof(t_server_message),32)))
			    {
		                munge(&client);
				printf("Got SERVER_MESSAGE packet with bad or missing speaker\n");
				break;
			    }
			    if (!(message = packet_get_str_const(rpacket,sizeof(t_server_message)+strlen(speaker)+1,1024)))
			    {
		                munge(&client);
				printf("Got SERVER_MESSAGE packet with bad or missing message (speaker=\"%s\" start=%u len=%u)\n",speaker,sizeof(t_server_message)+strlen(speaker)+1,packet_get_size(rpacket));
				break;
			    }
			    
			    switch (bn_int_get(rpacket->u.server_message.type))
			    {
			    case SERVER_MESSAGE_TYPE_JOIN:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_green,"\"%s\" %s enters\n",speaker,
				            mflags_get_str(bn_int_get(rpacket->u.server_message.flags)));
				break;
			    case SERVER_MESSAGE_TYPE_CHANNEL:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_green,"Joining channel :\"%s\" %s\n",message,
				            cflags_get_str(bn_int_get(rpacket->u.server_message.flags)));
				break;
			    case SERVER_MESSAGE_TYPE_ADDUSER:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_green,"\"%s\" %s is here\n",speaker,
				            mflags_get_str(bn_int_get(rpacket->u.server_message.flags)));
				break;
			    case SERVER_MESSAGE_TYPE_USERFLAGS:
				break;
			    case SERVER_MESSAGE_TYPE_PART:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_green,"\"%s\" %s leaves\n",speaker,
				            mflags_get_str(bn_int_get(rpacket->u.server_message.flags)));
				break;
			    case SERVER_MESSAGE_TYPE_WHISPER:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_blue,"<From: %s>",speaker);
				printf(" ");
				str_print_term(stdout,message,0,0);
				printf("\n");
				break;
			    case SERVER_MESSAGE_TYPE_WHISPERACK:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_blue,"<To: %s>",speaker);
				printf(" ");
				str_print_term(stdout,message,0,0);
				printf("\n");
				break;
			    case SERVER_MESSAGE_TYPE_BROADCAST:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_yellow,"<Broadcast %s> %s\n",speaker,message);
				break;
			    case SERVER_MESSAGE_TYPE_ERROR:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_red,"<Error> %s\n",message);
				break;
			    case SERVER_MESSAGE_TYPE_INFO:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_yellow,"<Info> %s\n",message);
				break;
			    case SERVER_MESSAGE_TYPE_EMOTE:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_yellow,"<%s %s>\n",speaker,message);
				break;
			    default:
			    case SERVER_MESSAGE_TYPE_TALK:
		                munge(&client);
				ansi_printf(&client,ansi_text_color_yellow,"<%s>",speaker);
				printf(" ");
				str_print_term(stdout,message,0,0);
				printf("\n");
			    }
			}
			break;
			
		    default:
		        munge(&client);
			printf("Unsupported server packet type 0x%04x\n",packet_get_type(rpacket));
			hexdump(stdout,packet_get_data_const(rpacket,0,packet_get_size(rpacket)),packet_get_size(rpacket));
			printf("\n");
		    }
		    
		    client.currsize = 0;
		    break;
		    
		case -1: /* error (probably connection closed) */
		default:
		    munge(&client);
		    printf("----\nConnection closed by server.\n");
		    psock_close(client.sd);
		    if (client.changed_in)
			tcsetattr(client.fd_stdin,TCSAFLUSH,&client.in_attr_old);
		    return STATUS_SUCCESS;
		}
	    }
	}
    }
    
    /* not reached */
}