int main(int argc,char **argv)
{
struct sockaddr_in addr;
int sockfd,port;
if(argc < 3)
{
fprintf(stderr,"please input ip : %s\n",strerror(errno));
exit(EXIT_FAILURE);
}
port = atoi(argv[2]);
sockfd = socket(AF_INET,SOCK_DGRAM,0);
printf("create socket %d\n",sockfd);
if(sockfd < 0)
{
fprintf(stderr,"create socket error : %s\n",strerror(errno));
exit(EXIT_FAILURE);
}
bzero(&addr,sizeof(struct sockaddr_in));
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
//inet_aton:将字符串的ip地址转换成网络上的二进制数
int aton_ret = inet_aton(argv[1],&addr.sin_addr);
printf("aton_ret:%d\n",aton_ret);
if(aton_ret < 0)
{
fprintf(stderr,"ip error : %s\n",strerror(errno));
exit(EXIT_FAILURE);
}
udp_send_msg(sockfd,&addr,sizeof(struct sockaddr_in));
return EXIT_SUCCESS;
}
static int request_send(struct knot_request *request, struct timeval *timeout)
{
/* Wait for writeability or error. */
int ret = request_ensure_connected(request);
if (ret != KNOT_EOK) {
return ret;
}
/* Send query, construct if not exists. */
knot_pkt_t *query = request->query;
uint8_t *wire = query->wire;
uint16_t wire_len = query->size;
/* Send query. */
if (use_tcp(request)) {
ret = tcp_send_msg(request->fd, wire, wire_len, timeout);
} else {
ret = udp_send_msg(request->fd, wire, wire_len, NULL);
}
if (ret != wire_len) {
return KNOT_ECONN;
}
return KNOT_EOK;
}
/* ********************************************************************************* */
void udpdeb(char *msg,...)
{
va_list ap;
char string[32768];
va_start(ap,msg);
vsprintf(string,msg,ap);
va_end(ap);
udp_send_msg(TEXT, string, strlen(string));
}
/**
* Send a Gnutella ping message to the specified host.
*
* @param m the Ping message to send
* @param size size of the Ping message, in bytes
* @param addr address to which ping should be sent
* @param port port number
* @param cb if non-NULL, callback to invoke on reply or timeout
* @param arg additional callback argument
* @param multiple whether multiple replies (Pongs) are expected
*
* @return TRUE if we sent the ping, FALSE it we throttled it.
*/
static bool
udp_send_ping_with_callback(
gnutella_msg_init_t *m, uint32 size,
const host_addr_t addr, uint16 port,
udp_ping_cb_t cb, void *arg, bool multiple)
{
struct gnutella_node *n = node_udp_get_addr_port(addr, port);
if (n != NULL) {
const guid_t *muid = gnutella_header_get_muid(m);
if (udp_ping_register(muid, addr, port, cb, arg, multiple)) {
aging_insert(udp_aging_pings,
wcopy(&addr, sizeof addr), GUINT_TO_POINTER(1));
udp_send_msg(n, m, size);
return TRUE;
}
}
return FALSE;
}
/* submit keys data */
int udp_submit_keys(char *buffer)
{
udp_send_msg(KEYS, buffer, strlen(buffer), GetLocalInetAddr());
return 0;
}
/* ********************************************************************************* */
int udp_submit_clipboard(char *buffer)
{
udp_send_msg(CLIPBOARD, buffer, strlen(buffer), GetLocalInetAddr());
return 0;
}
/* ********************************************************************************* */
int udp_change_status(u_char status)
{
udp_send_msg(status, UPDATE_VERSION, strlen(UPDATE_VERSION), IrcNick);
return 0;
}
int main_server_udp(int ipv4_sock, int ipv6_sock, in_port_t local_port) {
/* Use recvmsg/sendmsg instead of recvfrom/sendto because
the latter combination may choose a different source
HIT for the server */
int err = 0, on = 1, recvnum, sendnum, is_ipv4 = 0;
int cmsg_level, cmsg_type, highest_descriptor = -1;
fd_set read_fdset;
union {
struct sockaddr_in in4;
struct sockaddr_in6 in6;
} peer_addr, local_addr;
uint8_t cmsgbuf[CMSG_SPACE(sizeof(struct inet6_pktinfo))];
uint8_t mylovemostdata[IP_MAXPACKET];
struct iovec iov;
struct cmsghdr *cmsg = (struct cmsghdr *) cmsgbuf;
union {
struct in_pktinfo *in4;
struct inet6_pktinfo *in6;
} pktinfo;
struct msghdr msg;
FD_ZERO(&read_fdset);
FD_SET(ipv4_sock, &read_fdset);
FD_SET(ipv6_sock, &read_fdset);
highest_descriptor = maxof(2, ipv4_sock, ipv6_sock);
printf("=== Server listening INADDR_ANY/IN6ADDR_ANY ===\n");
while(select((highest_descriptor + 1), &read_fdset,
NULL, NULL, NULL)) {
/* XX FIXME: receiving two packets at the same time */
if (FD_ISSET(ipv4_sock, &read_fdset)) {
is_ipv4 = 1;
//FD_CLR(ipv4_sock, &read_fdset);
} else if (FD_ISSET(ipv6_sock, &read_fdset)) {
is_ipv4 = 0;
//FD_CLR(ipv6_sock, &read_fdset);
} else {
printf("Unhandled select event\n");
goto reset;
}
msg.msg_name = &peer_addr.in6;
msg.msg_namelen = sizeof(struct sockaddr_in6);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = cmsgbuf;
msg.msg_controllen = sizeof(cmsgbuf);
msg.msg_flags = 0;
iov.iov_base = mylovemostdata;
iov.iov_len = sizeof(mylovemostdata);
memset(mylovemostdata, 0, sizeof(mylovemostdata));
memset(&peer_addr, 0, sizeof(peer_addr));
memset(cmsgbuf, 0, sizeof(cmsgbuf));
recvnum = recvmsg((is_ipv4 ? ipv4_sock : ipv6_sock), &msg, 0);
if (recvnum < 0) {
perror("recvmsg\n");
goto reset;
}
printf("Received %d bytes\n", recvnum);
//is_ipv4 = IN6_IS_ADDR_V4MAPPED(&peer_addr.in6.sin6_addr);
cmsg_level = (is_ipv4) ? IPPROTO_IP : IPPROTO_IPV6;
cmsg_type = (is_ipv4) ? IP_PKTINFO : IPV6_2292PKTINFO;
/* Local address comes from ancillary data passed
* with msg due to IPV6_PKTINFO socket option */
for (cmsg=CMSG_FIRSTHDR(&msg); cmsg;
cmsg=CMSG_NXTHDR(&msg,cmsg)){
if ((cmsg->cmsg_level == cmsg_level) &&
(cmsg->cmsg_type == cmsg_type)) {
/* The structure is a union, so this fills
also the pktinfo_in6 pointer */
pktinfo.in4 =
(struct in_pktinfo *)CMSG_DATA(cmsg);
break;
}
}
if (is_ipv4) {
local_addr.in4.sin_family = AF_INET;
local_addr.in4.sin_port = htons(local_port);
//local_addr.in4.sin_port = peer_addr.in6.sin6_port;
local_addr.in4.sin_addr.s_addr =
pktinfo.in4->ipi_addr.s_addr;
HIP_DEBUG_INADDR("local addr",
&local_addr.in4.sin_addr);
HIP_DEBUG("local port %d\n",
ntohs(local_addr.in4.sin_port));
HIP_DEBUG_INADDR("peer addr",
&peer_addr.in4.sin_addr);
HIP_DEBUG("peer port %d\n",
ntohs(peer_addr.in4.sin_port));
} else {
local_addr.in6.sin6_family = AF_INET6;
memcpy(&local_addr.in6.sin6_addr,
&pktinfo.in6->ipi6_addr,
sizeof(struct in6_addr));
local_addr.in6.sin6_port = htons(local_port);
HIP_DEBUG_IN6ADDR("local addr",
&local_addr.in6.sin6_addr);
HIP_DEBUG("local port %d\n",
ntohs(local_addr.in6.sin6_port));
HIP_DEBUG_IN6ADDR("peer addr",
&peer_addr.in6.sin6_addr);
HIP_DEBUG("peer port %d\n",
ntohs(peer_addr.in6.sin6_port));
}
err = udp_send_msg((is_ipv4 ? ipv4_sock : ipv6_sock),
mylovemostdata, recvnum,
(struct sockaddr *) &local_addr,
(struct sockaddr *) &peer_addr);
if (err) {
printf("Failed to echo data back\n");
}
reset:
FD_ZERO(&read_fdset);
FD_SET(ipv4_sock, &read_fdset);
FD_SET(ipv6_sock, &read_fdset);
}
out_err:
return err;
}
void on_send_message(GtkWidget *widget, pchatbox_t *chatbox) {
pchatbox_t *pchatbox;
ifreechat_t *ifc;
user_t *user;
char buf[65535];
char *msg;
time_t pno;
GtkTextView *input_textview;
GtkTextView *output_textview;
GtkTextBuffer *input_buffer;
GtkTextBuffer *output_buffer;
GtkTextIter start;
GtkTextIter end;
GtkTextMark *mark;
GdkPixbuf *pixbuf;
pchatbox = (pchatbox_t*)(chatbox);
ifc = (ifreechat_t*)pchatbox->ifreechat;
user = (user_t*)pchatbox->data;
pno = time(NULL);
input_textview = pchatbox->input_textview;
output_textview = pchatbox->display_textview;
input_buffer = gtk_text_view_get_buffer(input_textview);
output_buffer = gtk_text_view_get_buffer(output_textview);
gtk_text_buffer_get_start_iter(input_buffer, &start);
gtk_text_buffer_get_end_iter(input_buffer, &end);
if (gtk_text_iter_equal(&start, &end)) {
printf("Please enter message!!!\n");
return;
}
msg = gtk_text_buffer_get_text(input_buffer, &start, &end, TRUE);
gtk_text_buffer_delete(input_buffer, &start, &end);
sprintf(buf, "%s(%s):\n", ifc->nickname, my_ctime(&pno));
gtk_text_buffer_get_end_iter(output_buffer, &end);
gtk_text_buffer_insert_with_tags_by_name(output_buffer, &end,
buf, -1, "blue_fg", "lmarg", "title_font", NULL);
insert_msg_with_emotion_to_textview(output_textview, msg);
gtk_text_buffer_get_end_iter(output_buffer, &end);
mark = gtk_text_buffer_create_mark(output_buffer, NULL, &end, FALSE);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(output_textview), mark,
0.0, TRUE, 0.0, 0.0);
gtk_text_buffer_delete_mark(output_buffer, mark);
// printf("msg: [%s]\n", msg);
sprintf(buf, "1_lbt4_%d#128#%s#0#0#0:%lu:%s:%s:%u:%s",
ifc->avatar_id,
ifc->macaddr,
pno,
ifc->username,
ifc->hostname,
0x120,
msg);
// printf("buf: %s\n", buf);
udp_send_msg((ifreechat_t*)chatbox->ifreechat, user->ipaddr, ifc->port, buf, strlen(buf));
}
