Archipelago » qemu

/*

 * Changes and additions relating to SLiRP

 * Copyright (c) 1995 Danny Gasparovski.

 * terms and conditions of the copyright.

 */

{

	udb.so_next = udb.so_prev = &udb;

}

 * ip->ip_len length data (IPDU)

 */

void

	register struct udphdr *uh;

/*	struct mbuf *opts = 0;*/

	int len;

	struct socket *so;

	DEBUG_CALL("udp_input");

	DEBUG_ARG("m = %lx", (long)m);

	DEBUG_ARG("iphlen = %d", iphlen);

	udpstat.udps_ipackets++;

	/*

		m_adj(m, len - ip->ip_len);

		ip->ip_len = len;

	}

	/*

	 * Save a copy of the IP header in case we want restore it

	 * for sending an ICMP error message in response.

	 */

	save_ip.ip_len+= iphlen;         /* tcp_input subtracts this */

	/*

	  ((struct ipovly *)ip)->ih_x1 = 0;

	  ((struct ipovly *)ip)->ih_len = uh->uh_ulen;

	  /* keep uh_sum for ICMP reply

	   */

	  if(cksum(m, len + sizeof(struct ip))) {

	    udpstat.udps_badsum++;

	if (so->so_lport != uh->uh_sport ||

	    so->so_laddr.s_addr != ip->ip_src.s_addr) {

		struct socket *tmp;

		for (tmp = udb.so_next; tmp != &udb; tmp = tmp->so_next) {

			if (tmp->so_lport == uh->uh_sport &&

			    tmp->so_laddr.s_addr == ip->ip_src.s_addr) {

		  udp_last_so = so;

		}

	}

	if (so == NULL) {

	  /*

	   * If there's no socket for this packet,

	   */

	  if ((so = socreate()) == NULL) goto bad;

	  if(udp_attach(so) == -1) {

			errno,strerror(errno)));

	    sofree(so);

	    goto bad;

	  }

	  /*

	   * Setup fields

	   */

	  /* udp_last_so = so; */

	  so->so_laddr = ip->ip_src;

	  so->so_lport = uh->uh_sport;

	  if ((so->so_iptos = udp_tos(so)) == 0)

	    so->so_iptos = ip->ip_tos;

	  /*

	   * XXXXX Here, check if it's in udpexec_list,

	   * and if it is, do the fork_exec() etc.

	  m->m_data -= iphlen;

	  *ip=save_ip;

	  DEBUG_MISC((dfd,"udp tx errno = %d-%s\n",errno,strerror(errno)));

	}

	m_free(so->so_m);   /* used for ICMP if error on sorecvfrom */

	return;

}

                struct sockaddr_in *saddr, struct sockaddr_in *daddr,

                int iptos)

{

	 */

	m->m_data -= sizeof(struct udpiphdr);

	m->m_len += sizeof(struct udpiphdr);

	/*

	 * Fill in mbuf with extended UDP header

	 * and addresses and length put into network format.

	((struct ip *)ui)->ip_ttl = ip_defttl;

	((struct ip *)ui)->ip_tos = iptos;

	udpstat.udps_opackets++;

	error = ip_output(so, m);

	return (error);

}

               struct sockaddr_in *addr)

{

    }

    daddr.sin_addr = so->so_laddr;

    daddr.sin_port = so->so_lport;

    return udp_output2(so, m, &saddr, &daddr, so->so_iptos);

}

     struct socket *so;

{

  struct sockaddr_in addr;

  if((so->s = socket(AF_INET,SOCK_DGRAM,0)) != -1) {

    /*

     * Here, we bind() the socket.  Although not really needed

	struct socket *so;

{

	int i = 0;

	while(udptos[i].tos) {

		if ((udptos[i].fport && ntohs(so->so_fport) == udptos[i].fport) ||

		    (udptos[i].lport && ntohs(so->so_lport) == udptos[i].lport)) {

		}

		i++;

	}

	return 0;

}

	CTL_MSG *nmsg;

	char buff[sizeof(CTL_MSG)];

	u_char type;

struct talk_request {

	struct talk_request *next;

	struct socket *udp_so;

	struct socket *tcp_so;

} *req;

#endif

struct cu_header {

	uint16_t	d_family;		// destination family

	uint16_t	d_port;			// destination port

		 */

		if (getsockname(so->s, (struct sockaddr *)&addr, &addrlen) < 0)

			return;

#define	IS_OLD	(so->so_emu == EMU_TALK)

#define COPY_MSG(dest, src) { dest->type = src->type; \

			OTOSIN(omsg, ctl_addr)->sin_port = addr.sin_port;

			OTOSIN(omsg, ctl_addr)->sin_addr = our_addr;

			strncpy(omsg->l_name, getlogin(), NAME_SIZE_OLD);

			omsg = (CTL_MSG_OLD *) buff;

			nmsg = mtod(m, CTL_MSG *);

			type = nmsg->type;

			OTOSIN(nmsg, ctl_addr)->sin_addr = our_addr;

			strncpy(nmsg->l_name, getlogin(), NAME_SIZE_OLD);

		}

			return;		/* for LOOK_UP this is enough */

		if (IS_OLD) {		/* make a copy of the message */

			COPY_MSG(nmsg, omsg);

			nmsg->vers = 1;

		 * ports, 517 and 518. This is why we have two copies

		 * of the message, one in old talk and one in new talk

		 * format.

		if (type == ANNOUNCE) {

			int s;

			u_short temp_port;

			for(req = req_tbl; req; req = req->next)

				if (so == req->udp_so)

					break;  	/* found it */

			if (!req) {	/* no entry for so, create new */

				req = (struct talk_request *)

					malloc(sizeof(struct talk_request));

				req->udp_so = so;

					OTOSIN(omsg, addr)->sin_port,

					SS_FACCEPTONCE);

				req->next = req_tbl;

				req_tbl = req;

			/* replace port number in addr field */

			addrlen = sizeof(addr);

					(struct sockaddr *) &addr,

			OTOSIN(omsg, addr)->sin_port = addr.sin_port;

			OTOSIN(omsg, addr)->sin_addr = our_addr;

			OTOSIN(nmsg, addr)->sin_port = addr.sin_port;

			/* send LEAVE_INVITEs */

			temp_port = OTOSIN(omsg, ctl_addr)->sin_port;

			OTOSIN(omsg, ctl_addr)->sin_port = 0;

			OTOSIN(nmsg, ctl_addr)->sin_port = 0;

			s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);

			addr.sin_addr = our_addr;

			addr.sin_family = AF_INET;

			addr.sin_port = htons(517);

				(struct sockaddr *)&addr, sizeof(addr));

			addr.sin_port = htons(518);

			sendto(s, (char *)nmsg, sizeof(*nmsg), 0,

				(struct sockaddr *) &addr, sizeof(addr));

			closesocket(s) ;

			OTOSIN(omsg, ctl_addr)->sin_port = temp_port;

			OTOSIN(nmsg, ctl_addr)->sin_port = temp_port;

		}

		 * If it is a DELETE message, we send a copy to the

		 * local daemons. Then we delete the entry corresponding

		 * to our socket from the request table.

		 */

		if (type == DELETE) {

			struct talk_request *temp_req, *req_next;

			int s;

			u_short temp_port;

			temp_port = OTOSIN(omsg, ctl_addr)->sin_port;

			OTOSIN(omsg, ctl_addr)->sin_port = 0;

			OTOSIN(nmsg, ctl_addr)->sin_port = 0;

			s = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);

			addr.sin_addr = our_addr;

			addr.sin_family = AF_INET;

			sendto(s, (char *)nmsg, sizeof(*nmsg), 0,

				(struct sockaddr *)&addr, sizeof(addr));

			closesocket(s);

			OTOSIN(omsg, ctl_addr)->sin_port = temp_port;

			OTOSIN(nmsg, ctl_addr)->sin_port = temp_port;

				}

			}

		}

#endif

		/*

		 * Cu-SeeMe emulation.

		 * Hopefully the packet is more that 16 bytes long. We don't

		 * do any other tests, just replace the address and port

		 * fields.

		if (m->m_len >= sizeof (*cu_head)) {

			if (getsockname(so->s, (struct sockaddr *)&addr, &addrlen) < 0)

				return;

			cu_head->s_port = addr.sin_port;

			cu_head->so_addr = our_addr.s_addr;

		}

		return;

	}

}

	struct sockaddr_in addr;

	struct socket *so;

	int addrlen = sizeof(struct sockaddr_in), opt = 1;

	if ((so = socreate()) == NULL) {

		free(so);

		return NULL;

	}

	setsockopt(so->s,SOL_SOCKET,SO_REUSEADDR,(char *)&opt,sizeof(int));

/*	setsockopt(so->s,SOL_SOCKET,SO_OOBINLINE,(char *)&opt,sizeof(int)); */

	getsockname(so->s,(struct sockaddr *)&addr,&addrlen);

	so->so_fport = addr.sin_port;

	if (addr.sin_addr.s_addr == 0 || addr.sin_addr.s_addr == loopback_addr.s_addr)

	   so->so_faddr = alias_addr;

	else

	   so->so_faddr = addr.sin_addr;

	so->so_lport = lport;

	so->so_laddr.s_addr = laddr;

	if (flags != SS_FACCEPTONCE)

	   so->so_expire = 0;

	so->so_state = SS_ISFCONNECTED;

	return so;

}