ps2ipc.c File Reference

#include <tamtypes.h>
#include <string.h>
#include <kernel.h>
#include <sifrpc.h>
#include <ps2ips.h>
#include <ps2ip_rpc.h>

Include dependency graph for ps2ipc.c:

Go to the source code of this file.

Functions
int	ps2ip_init (void)
void	ps2ip_deinit (void)
int	accept (int s, struct sockaddr *addr, int *addrlen)
int	bind (int s, struct sockaddr *name, int namelen)
int	disconnect (int s)
int	connect (int s, struct sockaddr *name, int namelen)
int	listen (int s, int backlog)
static void	recv_intr (void *data_raw)
int	recv (int s, void *mem, int len, unsigned int flags)
int	recvfrom (int s, void *mem, int len, unsigned int flags, struct sockaddr *from, int *fromlen)
int	send (int s, void *dataptr, int size, unsigned int flags)
int	sendto (int s, void *dataptr, int size, unsigned int flags, struct sockaddr *to, int tolen)
int	socket (int domain, int type, int protocol)
int	ps2ip_setconfig (t_ip_info *ip_info)
int	ps2ip_getconfig (char *netif_name, t_ip_info *ip_info)
int	select (int maxfdp1, struct fd_set *readset, struct fd_set *writeset, struct fd_set *exceptset, struct timeval *timeout)
int	ioctlsocket (int s, long cmd, void *argp)
int	getsockname (int s, struct sockaddr *name, int *namelen)
int	getpeername (int s, struct sockaddr *name, int *namelen)
int	getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen)
int	setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen)

Variables
static int	_init_check = 0
static int	lock_sema = -1
static SifRpcClientData_t	_ps2ip
struct {
union {
s32   result
s32   s
cmd_pkt   cmd_pkt
listen_pkt   listen_pkt
s_recv_pkt   s_recv_pkt
r_recv_pkt   r_recv_pkt
send_pkt   send_pkt
socket_pkt   socket_pkt
t_ip_info   ip_info
char   netif_name [8]
select_pkt   select_pkt
ioctl_pkt   ioctl_pkt
getsockopt_pkt   getsockopt_pkt
getsockopt_res_pkt   getsockopt_res_pkt
setsockopt_pkt   setsockopt_pkt
char   hostname [256]
gethostbyname_res_pkt   gethostbyname_res_pkt
dns_setserver_pkt   dns_setserver_pkt
dns_getserver_res_pkt   dns_getserver_res_pkt
u8   numdns
u8   buffer [512]
}
}	_rpc_buffer
static int	_intr_data [32]
static ip_addr_t	dns_servers [DNS_MAX_SERVERS]
const ip_addr_t	ip_addr_any = IPADDR4_INIT(IPADDR_ANY)

Detailed Description

ps2ip ee client to iop ps2ip.

Definition in file ps2ipc.c.

Function Documentation

accept()

int accept	(	int	s,
		struct sockaddr *	addr,
		int *	addrlen
	)

Definition at line 95 of file ps2ipc.c.

{
        int result;
        cmd_pkt *pkt = &_rpc_buffer.cmd_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->socket = s;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_ACCEPT, 0, (void*)pkt, sizeof(s32), (void*)pkt, sizeof(cmd_pkt), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        if(addr != NULL)
        {
                if(pkt->len < *addrlen) *addrlen = pkt->len;
                memcpy((void *)addr, (void *)&pkt->sockaddr, *addrlen);
        }
 
        result = pkt->socket;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, cmd_pkt::len, lock_sema, NULL, PS2IPS_ID_ACCEPT, result, s, SifCallRpc(), SignalSema(), cmd_pkt::sockaddr, cmd_pkt::socket, and WaitSema().

bind()

int bind	(	int	s,
		struct sockaddr *	name,
		int	namelen
	)

Definition at line 125 of file ps2ipc.c.

{
        cmd_pkt *pkt = &_rpc_buffer.cmd_pkt;
        int result;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->socket = s;
        pkt->len = namelen;
        memcpy((void *)&pkt->sockaddr, (void *)name, sizeof(struct sockaddr));
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_BIND, 0, (void*)pkt, sizeof(cmd_pkt), (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, cmd_pkt::len, lock_sema, NULL, PS2IPS_ID_BIND, result, s, SifCallRpc(), SignalSema(), cmd_pkt::sockaddr, cmd_pkt::socket, and WaitSema().

connect()

int connect	(	int	s,
		struct sockaddr *	name,
		int	namelen
	)

Definition at line 174 of file ps2ipc.c.

{
        int result;
        cmd_pkt *pkt = &_rpc_buffer.cmd_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->socket = s;
        pkt->len = namelen;
        memcpy((void *)&pkt->sockaddr, (void *)name, sizeof(struct sockaddr));
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_CONNECT, 0, (void*)pkt, sizeof(cmd_pkt), (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, cmd_pkt::len, lock_sema, NULL, PS2IPS_ID_CONNECT, result, s, SifCallRpc(), SignalSema(), cmd_pkt::sockaddr, cmd_pkt::socket, and WaitSema().

disconnect()

int disconnect

(

int

s

)

Definition at line 151 of file ps2ipc.c.

{
        int result;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        _rpc_buffer.s = s;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_DISCONNECT, 0, (void*)&_rpc_buffer.s, sizeof(s32), (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, lock_sema, NULL, PS2IPS_ID_DISCONNECT, result, s, SifCallRpc(), SignalSema(), and WaitSema().

Referenced by serverThread().

getpeername()

int getpeername	(	int	s,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 583 of file ps2ipc.c.

{
        int result;
        cmd_pkt *pkt = &_rpc_buffer.cmd_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->socket = s;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_GETPEERNAME, 0, (void*)pkt, sizeof(pkt->socket), (void*)pkt, sizeof(cmd_pkt), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        if(pkt->len < *namelen) *namelen = pkt->len;
        memcpy((void *)name, (void *)&pkt->sockaddr, *namelen);
 
        result = pkt->socket;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, cmd_pkt::len, lock_sema, NULL, PS2IPS_ID_GETPEERNAME, result, s, SifCallRpc(), SignalSema(), cmd_pkt::sockaddr, cmd_pkt::socket, and WaitSema().

getsockname()

int getsockname	(	int	s,
		struct sockaddr *	name,
		int *	namelen
	)

Definition at line 556 of file ps2ipc.c.

{
        int result;
        cmd_pkt *pkt = &_rpc_buffer.cmd_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->socket = s;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_GETSOCKNAME, 0, (void*)pkt, sizeof(pkt->socket), (void*)pkt, sizeof(cmd_pkt), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        if(pkt->len < *namelen) *namelen = pkt->len;
        memcpy((void *)name, (void *)&pkt->sockaddr, *namelen);
 
        result = pkt->socket;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, cmd_pkt::len, lock_sema, NULL, PS2IPS_ID_GETSOCKNAME, result, s, SifCallRpc(), SignalSema(), cmd_pkt::sockaddr, cmd_pkt::socket, and WaitSema().

getsockopt()

int getsockopt	(	int	s,
		int	level,
		int	optname,
		void *	optval,
		socklen_t *	optlen
	)

Definition at line 610 of file ps2ipc.c.

{
        getsockopt_pkt *pkt = &_rpc_buffer.getsockopt_pkt;
        getsockopt_res_pkt *res_pkt = &_rpc_buffer.getsockopt_res_pkt;
        int result;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->s = s;
        pkt->level = level;
        pkt->optname = optname;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_GETSOCKOPT, 0, (void*)pkt, sizeof(getsockopt_pkt), (void*)res_pkt, sizeof(getsockopt_res_pkt), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        if(res_pkt->optlen < *optlen) *optlen = res_pkt->optlen;
        memcpy((void*)optval, res_pkt->buffer, *optlen);
 
        result = res_pkt->result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, getsockopt_res_pkt::buffer, getsockopt_pkt::level, lock_sema, NULL, getsockopt_res_pkt::optlen, getsockopt_pkt::optname, PS2IPS_ID_GETSOCKOPT, getsockopt_res_pkt::result, result, getsockopt_pkt::s, s, SifCallRpc(), SignalSema(), and WaitSema().

ioctlsocket()

int ioctlsocket	(	int	s,
		long	cmd,
		void *	argp
	)

Definition at line 525 of file ps2ipc.c.

{
        int result;
        ioctl_pkt *pkt = &_rpc_buffer.ioctl_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->s = s;
        pkt->cmd = (s32)cmd;
        pkt->argp = argp;
        if( argp )
                pkt->value = *(s32*)argp;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_IOCTL, 0, (void*)pkt, sizeof(ioctl_pkt), (void*)pkt, sizeof(ioctl_pkt), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        if( argp )
                *(s32*)argp = pkt->value;
 
        result = pkt->result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, ioctl_pkt::argp, ioctl_pkt::cmd, ioctl_pkt, lock_sema, NULL, PS2IPS_ID_IOCTL, ioctl_pkt::result, result, ioctl_pkt::s, s, SifCallRpc(), SignalSema(), ioctl_pkt::value, and WaitSema().

listen()

int listen	(	int	s,
		int	backlog
	)

Definition at line 200 of file ps2ipc.c.

{
        int result;
        listen_pkt *pkt = &_rpc_buffer.listen_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->s = s;
        pkt->backlog = backlog;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_LISTEN, 0, (void*)pkt, sizeof(listen_pkt), (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, listen_pkt::backlog, lock_sema, NULL, PS2IPS_ID_LISTEN, result, listen_pkt::s, s, SifCallRpc(), SignalSema(), and WaitSema().

ps2ip_deinit()

void ps2ip_deinit

(

void

)

Definition at line 86 of file ps2ipc.c.

{
        if (lock_sema >= 0)
                DeleteSema(lock_sema);
        lock_sema = -1;
 
        _init_check = 0;
}

References _init_check, DeleteSema(), and lock_sema.

ps2ip_getconfig()

int ps2ip_getconfig	(	char *	netif_name,
		t_ip_info *	ip_info
	)

Definition at line 450 of file ps2ipc.c.

{
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        // call with netif name
        strncpy(_rpc_buffer.netif_name, netif_name, sizeof(_rpc_buffer.netif_name));
        _rpc_buffer.netif_name[sizeof(_rpc_buffer.netif_name) - 1] = '\0';
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_GETCONFIG, 0, (void*)_rpc_buffer.netif_name, sizeof(_rpc_buffer.netif_name), (void*)&_rpc_buffer.ip_info, sizeof(t_ip_info), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        // return config
        memcpy(ip_info, &_rpc_buffer.ip_info, sizeof(t_ip_info));
 
        SignalSema(lock_sema);
 
        return 1;
}

References _init_check, _ps2ip, _rpc_buffer, t_ip_info::dhcp_enabled, DHCP_STATE_OFF, t_ip_info::dhcp_status, t_ip_info::gw, t_ip_info::hw_addr, ip_info, t_ip_info::ipaddr, lock_sema, netif_dhcp_data, netif_find(), t_ip_info::netif_name, netif_name, t_ip_info::netmask, NULL, PS2IPS_ID_GETCONFIG, in_addr::s_addr, SifCallRpc(), SignalSema(), and WaitSema().

ps2ip_init()

int ps2ip_init

(

void

)

Definition at line 60 of file ps2ipc.c.

{
        ee_sema_t sema;
 
        while(1)
        {
                if(SifBindRpc(&_ps2ip, PS2IP_IRX, 0) < 0)
                        return -1;
 
                if(_ps2ip.server != NULL)
                        break;
 
                nopdelay();
        }
 
        sema.init_count = 1;
        sema.max_count = 1;
        sema.option = (u32)"ps2ipc";
        sema.attr = 0;
        lock_sema = CreateSema(&sema);
 
        _init_check = 1;
 
        return 0;
}

References _init_check, _ps2ip, ee_sema_t::attr, CreateSema(), ee_sema_t::init_count, lock_sema, ee_sema_t::max_count, nopdelay(), NULL, ee_sema_t::option, PS2IP_IRX, SifRpcClientData_t::server, and SifBindRpc().

Referenced by main().

ps2ip_setconfig()

int ps2ip_setconfig

(

t_ip_info *

ip_info

)

Definition at line 426 of file ps2ipc.c.

{
        int result;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        // return config
        memcpy(&_rpc_buffer.ip_info, ip_info, sizeof(t_ip_info));
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_SETCONFIG, 0, (void*)&_rpc_buffer.ip_info, sizeof(t_ip_info), (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, ip_info, lock_sema, NULL, PS2IPS_ID_SETCONFIG, result, SifCallRpc(), SignalSema(), and WaitSema().

recv()

int recv	(	int	s,
		void *	mem,
		int	len,
		unsigned int	flags
	)

Definition at line 240 of file ps2ipc.c.

{
        int result;
        s_recv_pkt *send_pkt = &_rpc_buffer.s_recv_pkt;
        r_recv_pkt *recv_pkt = &_rpc_buffer.r_recv_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        send_pkt->socket = s;
        send_pkt->length = len;
        send_pkt->flags = flags;
        send_pkt->ee_addr = mem;
        send_pkt->intr_data = _intr_data;
 
        if( !IS_UNCACHED_SEG(mem))
                SifWriteBackDCache(mem, len);
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_RECV, 0, (void*)send_pkt, sizeof(s_recv_pkt),
                                (void*)recv_pkt, sizeof(r_recv_pkt), recv_intr, _intr_data) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = recv_pkt->ret;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _intr_data, _ps2ip, _rpc_buffer, send_pkt::ee_addr, send_pkt::flags, IS_UNCACHED_SEG, send_pkt::length, lock_sema, PS2IPS_ID_RECV, recv_intr(), result, r_recv_pkt::ret, s, SifCallRpc(), SifWriteBackDCache(), SignalSema(), send_pkt::socket, and WaitSema().

recv_intr()

static void recv_intr ( void *  data_raw )

static

Definition at line 225 of file ps2ipc.c.

{
        rests_pkt *rests = UNCACHED_SEG(data_raw);
        int i;
 
        if(rests->ssize)
                for(i = 0; i < rests->ssize; i++)
                        rests->sbuf[i] = rests->sbuffer[i];
 
        if(rests->esize)
                for(i = 0; i < rests->esize; i++)
                        rests->ebuf[i] = rests->ebuffer[i];
}

References rests_pkt::ebuf, rests_pkt::ebuffer, rests_pkt::esize, rests_pkt::sbuf, rests_pkt::sbuffer, rests_pkt::ssize, and UNCACHED_SEG.

Referenced by recv(), and recvfrom().

recvfrom()

int recvfrom	(	int	s,
		void *	mem,
		int	len,
		unsigned int	flags,
		struct sockaddr *	from,
		int *	fromlen
	)

Definition at line 273 of file ps2ipc.c.

{
        int result;
        s_recv_pkt *send_pkt = &_rpc_buffer.s_recv_pkt;
        r_recv_pkt *recv_pkt = &_rpc_buffer.r_recv_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        send_pkt->socket = s;
        send_pkt->length = len;
        send_pkt->flags = flags;
        send_pkt->ee_addr = mem;
        send_pkt->intr_data = _intr_data;
 
        if( !IS_UNCACHED_SEG(mem))
                SifWriteBackDCache(mem, len);
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_RECVFROM, 0, (void*)send_pkt, sizeof(s_recv_pkt),
                                (void*)recv_pkt, sizeof(r_recv_pkt), recv_intr, _intr_data) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        memcpy((void *)from, (void *)&recv_pkt->sockaddr, sizeof(struct sockaddr));
        *fromlen = sizeof(struct sockaddr);
 
        result = recv_pkt->ret;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _intr_data, _ps2ip, _rpc_buffer, send_pkt::ee_addr, send_pkt::flags, IS_UNCACHED_SEG, send_pkt::length, lock_sema, PS2IPS_ID_RECVFROM, recv_intr(), result, r_recv_pkt::ret, s, SifCallRpc(), SifWriteBackDCache(), SignalSema(), r_recv_pkt::sockaddr, send_pkt::socket, and WaitSema().

select()

int select	(	int	maxfdp1,
		struct fd_set *	readset,
		struct fd_set *	writeset,
		struct fd_set *	exceptset,
		struct timeval *	timeout
	)

Definition at line 474 of file ps2ipc.c.

{
        int result;
        select_pkt *pkt = &_rpc_buffer.select_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->maxfdp1 = maxfdp1;
        pkt->readset_p = readset;
        pkt->writeset_p = writeset;
        pkt->exceptset_p = exceptset;
        pkt->timeout_p = timeout;
        if( timeout )
                pkt->timeout = *timeout;
 
        if( readset )
                pkt->readset = *readset;
 
        if( writeset )
                pkt->writeset = *writeset;
 
        if( exceptset )
                pkt->exceptset = *exceptset;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_SELECT, 0, (void*)pkt, sizeof(select_pkt), (void*)pkt, sizeof(select_pkt), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        if( timeout )
                *timeout = pkt->timeout;
 
        if( readset )
                *readset = pkt->readset;
 
        if( writeset )
                *writeset = pkt->writeset;
 
        if( exceptset )
                *exceptset = pkt->exceptset;
 
        result = pkt->result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, select_pkt::exceptset, select_pkt::exceptset_p, lock_sema, select_pkt::maxfdp1, NULL, PS2IPS_ID_SELECT, select_pkt::readset, select_pkt::readset_p, select_pkt::result, result, SifCallRpc(), SignalSema(), select_pkt::timeout, select_pkt::timeout_p, WaitSema(), select_pkt::writeset, and select_pkt::writeset_p.

send()

int send	(	int	s,
		void *	dataptr,
		int	size,
		unsigned int	flags
	)

Definition at line 310 of file ps2ipc.c.

{
        int result;
        send_pkt *pkt = &_rpc_buffer.send_pkt;
        int miss;
 
        WaitSema(lock_sema);
 
        pkt->socket = s;
        pkt->length = size;
        pkt->flags = flags;
        pkt->ee_addr = dataptr;
 
        if((u32)dataptr & 0x3f)
        {
                miss = 64 - ((u32)dataptr & 0x3f);
                if(miss > size) miss = size;
 
        } else {
 
                miss = 0;
        }
 
        pkt->malign = miss;
 
        if( !IS_UNCACHED_SEG(dataptr))
                SifWriteBackDCache(dataptr, size);
 
        memcpy((void *)pkt->malign_buff, UNCACHED_SEG(dataptr), miss);
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_SEND, 0, (void*)pkt, sizeof(send_pkt),
                                (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _ps2ip, _rpc_buffer, send_pkt::ee_addr, send_pkt::flags, IS_UNCACHED_SEG, send_pkt::length, lock_sema, send_pkt::malign, send_pkt::malign_buff, NULL, PS2IPS_ID_SEND, result, s, SifCallRpc(), SifWriteBackDCache(), SignalSema(), send_pkt::socket, UNCACHED_SEG, and WaitSema().

sendto()

int sendto	(	int	s,
		void *	dataptr,
		int	size,
		unsigned int	flags,
		struct sockaddr *	to,
		int	tolen
	)

Definition at line 354 of file ps2ipc.c.

{
        int result;
        send_pkt *pkt = &_rpc_buffer.send_pkt;
        int miss;
 
        WaitSema(lock_sema);
 
        pkt->socket = s;
        pkt->length = size;
        pkt->flags = flags;
        pkt->ee_addr = dataptr;
        memcpy((void *)&pkt->sockaddr, (void *)to, sizeof(struct sockaddr));
 
        if((u32)dataptr & 0x3f)
        {
                miss = 64 - ((u32)dataptr & 0x3f);
                if(miss > size) miss = size;
 
        } else {
 
                miss = 0;
        }
 
        pkt->malign = miss;
 
        if( !IS_UNCACHED_SEG(dataptr))
                SifWriteBackDCache(dataptr, size);
 
        memcpy((void *)pkt->malign_buff, UNCACHED_SEG(dataptr), miss);
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_SENDTO, 0, (void*)pkt, sizeof(send_pkt),
                                (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _ps2ip, _rpc_buffer, send_pkt::ee_addr, send_pkt::flags, IS_UNCACHED_SEG, send_pkt::length, lock_sema, send_pkt::malign, send_pkt::malign_buff, NULL, PS2IPS_ID_SENDTO, result, s, SifCallRpc(), SifWriteBackDCache(), SignalSema(), send_pkt::sockaddr, send_pkt::socket, UNCACHED_SEG, and WaitSema().

setsockopt()

int setsockopt	(	int	s,
		int	level,
		int	optname,
		const void *	optval,
		socklen_t	optlen
	)

Definition at line 640 of file ps2ipc.c.

{
        setsockopt_pkt *pkt = &_rpc_buffer.setsockopt_pkt;
        int result;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->s = s;
        pkt->s = level;
        pkt->optname = optname;
        pkt->optlen = optlen;
 
        memcpy(pkt->buffer, optval, optlen);
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_SETSOCKOPT, 0, (void*)pkt, sizeof(setsockopt_pkt), (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, setsockopt_pkt::buffer, lock_sema, NULL, setsockopt_pkt::optlen, setsockopt_pkt::optname, PS2IPS_ID_SETSOCKOPT, result, setsockopt_pkt::s, s, SifCallRpc(), SignalSema(), and WaitSema().

socket()

int socket	(	int	domain,
		int	type,
		int	protocol
	)

Definition at line 400 of file ps2ipc.c.

{
        int result;
        socket_pkt *pkt = &_rpc_buffer.socket_pkt;
 
        if(!_init_check) return -1;
 
        WaitSema(lock_sema);
 
        pkt->domain = domain;
        pkt->type = type;
        pkt->protocol = protocol;
 
        if (SifCallRpc(&_ps2ip, PS2IPS_ID_SOCKET, 0, (void*)pkt, sizeof(socket_pkt), (void*)&_rpc_buffer.result, sizeof(s32), NULL, NULL) < 0)
        {
                SignalSema(lock_sema);
                return -1;
        }
 
        result = _rpc_buffer.result;
 
        SignalSema(lock_sema);
 
        return result;
}

References _init_check, _ps2ip, _rpc_buffer, socket_pkt::domain, lock_sema, NULL, socket_pkt::protocol, PS2IPS_ID_SOCKET, result, SifCallRpc(), SignalSema(), socket_pkt::type, and WaitSema().

Variable Documentation

_init_check

int _init_check = 0

static

Definition at line 24 of file ps2ipc.c.

Referenced by accept(), bind(), connect(), disconnect(), getpeername(), getsockname(), getsockopt(), ioctlsocket(), listen(), ps2ip_deinit(), ps2ip_getconfig(), ps2ip_init(), ps2ip_setconfig(), recv(), recvfrom(), select(), setsockopt(), and socket().

_intr_data

int _intr_data[32]

static

Definition at line 52 of file ps2ipc.c.

Referenced by recv(), and recvfrom().

_ps2ip

SifRpcClientData_t _ps2ip

static

Definition at line 26 of file ps2ipc.c.

Referenced by accept(), bind(), connect(), disconnect(), getpeername(), getsockname(), getsockopt(), ioctlsocket(), listen(), ps2ip_getconfig(), ps2ip_init(), ps2ip_setconfig(), recv(), recvfrom(), select(), send(), sendto(), setsockopt(), and socket().

struct { ... } _rpc_buffer

Referenced by accept(), bind(), connect(), disconnect(), getpeername(), getsockname(), getsockopt(), ioctlsocket(), listen(), ps2ip_getconfig(), ps2ip_setconfig(), recv(), recvfrom(), select(), send(), sendto(), setsockopt(), and socket().

buffer

u8 buffer[512]

Definition at line 49 of file ps2ipc.c.

cmd_pkt

cmd_pkt cmd_pkt

Definition at line 31 of file ps2ipc.c.

dns_getserver_res_pkt

dns_getserver_res_pkt dns_getserver_res_pkt

Definition at line 47 of file ps2ipc.c.

dns_servers

ip_addr_t dns_servers[DNS_MAX_SERVERS]

static

Definition at line 54 of file ps2ipc.c.

dns_setserver_pkt

dns_setserver_pkt dns_setserver_pkt

Definition at line 46 of file ps2ipc.c.

gethostbyname_res_pkt

gethostbyname_res_pkt gethostbyname_res_pkt

Definition at line 45 of file ps2ipc.c.

getsockopt_pkt

getsockopt_pkt getsockopt_pkt

Definition at line 41 of file ps2ipc.c.

getsockopt_res_pkt

getsockopt_res_pkt getsockopt_res_pkt

Definition at line 42 of file ps2ipc.c.

hostname

char hostname[256]

Definition at line 44 of file ps2ipc.c.

ioctl_pkt

ioctl_pkt ioctl_pkt

Definition at line 40 of file ps2ipc.c.

Referenced by ioctlsocket().

ip_addr_any

const ip_addr_t ip_addr_any = IPADDR4_INIT(IPADDR_ANY)

Definition at line 58 of file ps2ipc.c.

ip_info

t_ip_info ip_info

Definition at line 37 of file ps2ipc.c.

Referenced by ethApplyIPConfig(), ethGetDHCPStatus(), ethPrintIPConfig(), ps2ip_getconfig(), and ps2ip_setconfig().

listen_pkt

listen_pkt listen_pkt

Definition at line 32 of file ps2ipc.c.

lock_sema

int lock_sema = -1

static

Definition at line 25 of file ps2ipc.c.

Referenced by accept(), bind(), connect(), disconnect(), getpeername(), getsockname(), getsockopt(), ioctlsocket(), listen(), ps2ip_deinit(), ps2ip_getconfig(), ps2ip_init(), ps2ip_setconfig(), recv(), recvfrom(), select(), send(), sendto(), setsockopt(), and socket().

netif_name

char netif_name[8]

Definition at line 38 of file ps2ipc.c.

Referenced by ps2ip_getconfig().

numdns

u8 numdns

Definition at line 48 of file ps2ipc.c.

r_recv_pkt

r_recv_pkt r_recv_pkt

Definition at line 34 of file ps2ipc.c.

result

s32 result

Definition at line 29 of file ps2ipc.c.

Referenced by accept(), bind(), connect(), disconnect(), getpeername(), getsockname(), getsockopt(), ioctlsocket(), listen(), ps2ip_setconfig(), recv(), recvfrom(), select(), send(), sendto(), setsockopt(), and socket().

s

s32 s

Definition at line 30 of file ps2ipc.c.

Referenced by accept(), access(), bind(), connect(), destroy_symbol(), disconnect(), getpeername(), getsockname(), getsockopt(), ioctlsocket(), listen(), load_erl(), main(), read_erl(), recv(), recvfrom(), send(), sendto(), setsockopt(), sior_rpc_server(), unload_erl(), Vu0ScaleMatrix(), Vu0ScaleMatrixXYZ(), and VuxScaleMatrix().

s_recv_pkt

s_recv_pkt s_recv_pkt

Definition at line 33 of file ps2ipc.c.

select_pkt

select_pkt select_pkt

Definition at line 39 of file ps2ipc.c.

send_pkt

send_pkt send_pkt

Definition at line 35 of file ps2ipc.c.

setsockopt_pkt

setsockopt_pkt setsockopt_pkt

Definition at line 43 of file ps2ipc.c.

socket_pkt

socket_pkt socket_pkt

Definition at line 36 of file ps2ipc.c.