ps2ips.h File Reference

#include <tcpip.h>
#include <sys/time.h>

Include dependency graph for ps2ips.h:

This graph shows which files directly or indirectly include this file:

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)
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)
struct hostent *	gethostbyname (const char *name)
void	dns_setserver (u8 numdns, ip_addr_t *dnsserver)
const ip_addr_t *	dns_getserver (u8 numdns)

Detailed Description

PS2IP library.

Definition in file ps2ips.h.

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().

dns_getserver()

const ip_addr_t* dns_getserver

(

u8

numdns

)

Referenced by ethApplyIPConfig(), and ethPrintIPConfig().

dns_setserver()

void dns_setserver	(	u8	numdns,
		ip_addr_t *	dnsserver
	)

Referenced by ethApplyIPConfig(), and main().

gethostbyname()

struct hostent* gethostbyname

(

const char *

name

)

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 41 of file ps2ip.c.

{
        NetIF*  pNetIF=netif_find(pszName);
 
        if (pNetIF==NULL)
        {
                //Net interface not found.
                memset(pInfo,0,sizeof(*pInfo));
                return  0;
        }
        strcpy(pInfo->netif_name,pszName);
        pInfo->ipaddr.s_addr=pNetIF->ip_addr.addr;
        pInfo->netmask.s_addr=pNetIF->netmask.addr;
        pInfo->gw.s_addr=pNetIF->gw.addr;
 
        memcpy(pInfo->hw_addr,pNetIF->hwaddr,sizeof(pInfo->hw_addr));
 
#if LWIP_DHCP
        struct dhcp *dhcp = netif_dhcp_data(pNetIF);
 
        if ((dhcp != NULL) && (dhcp->state != DHCP_STATE_OFF))
        {
                pInfo->dhcp_enabled=1;
                pInfo->dhcp_status=dhcp->state;
        }
        else
        {
                pInfo->dhcp_enabled=0;
                pInfo->dhcp_status=DHCP_STATE_OFF;
        }
 
#else
        pInfo->dhcp_enabled=0;
#endif
 
        return  1;
}

References _init_check, _ps2ip, _rpc_buffer, ip_info, lock_sema, netif_name, NULL, PS2IPS_ID_GETCONFIG, SifCallRpc(), SignalSema(), and WaitSema().

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

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().

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().