e32socketmodule.cpp

python s60 1.4.5版本的源代码

  }
  new_so->ob_proto = protocol.iProtocol;
  new_so->ob_is_closed = 0;
  new_so->ob_is_connected = 1;
  new_so->SE = new_SE;

  PyObject* r;
  if (new_so->ob_proto == KProtocolInetTcp ) {
    TSockAddr remote;
    new_so->SE->iSocket.RemoteName(remote);
    char str[MaxIPAddrLength];
    PyOS_snprintf(str, MaxIPAddrLength, "%d.%d.%d.%d",
                  remote[0], remote[1], remote[2], remote[3]);
    r = Py_BuildValue("N(Ni)", new_so, PyString_FromString(str), remote.Port());
  }
  else { //BLUETOOTH
    TBTSockAddr remote;
    new_so->SE->iSocket.RemoteName(remote);
    TBuf<6> aBTA;
    aBTA.FillZ(6);
    aBTA.Copy(remote.BTAddr().Des());
    char str[MaxIPAddrLength+2];
    PyOS_snprintf(str, MaxIPAddrLength+2, "%02x:%02x:%02x:%02x:%02x:%02x",
                  aBTA[0],  aBTA[1],  aBTA[2],  aBTA[3],  aBTA[4],  aBTA[5]);
    r = Py_BuildValue("(Ns)", new_so, str);
  }
  return r;
}

extern "C" PyObject *
socket_bind(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED(self);

  TInt error = KErrNone;
  char* addr;
  int addr_len;
  int port;

  if (!PyArg_ParseTuple(args, "(s#i)", &addr, &addr_len, &port) ) {
    return NULL;
  }
  
  TSockAddr* address;
  TBTSockAddr bt_addr;
  TInetAddr inet_addr; 

  if ((self->ob_proto == KProtocolInetTcp) ||
      (self->ob_proto == KProtocolInetUdp)) { 
    error = set_symbian_inet_addr(inet_addr, addr, addr_len, port);
    address = &inet_addr;
  }
  else if (self->ob_proto == KRFCOMM) {
    bt_addr.SetPort(port);
    address = &bt_addr;
  }
  else
    return PySocket_Err("Unknown protocol");
 
  if (error == KErrNone) {
    Py_BEGIN_ALLOW_THREADS
    self->SE->iPort = address->Port();
    error = self->SE->iSocket.Bind(*address); 
    Py_END_ALLOW_THREADS
  }
  RETURN_SOCKET_ERROR_OR_PYNONE(error);
}

extern "C" PyObject *
socket_close(Socket_object *self)
{

  TStaticData* sd = GetServer();  
  self->SE->iSocket.CancelAll();
  self->SE->iSocket.Close();
  if (sd !=NULL) {
    sd->apo->started = EFalse;
    sd->apo->connection->Stop(RConnection::EStopNormal);
    sd->rss.Close();
  }
 
  self->ob_is_connected = 0;
  self->ob_is_closed = 1;
  Py_INCREF(Py_None);
  return Py_None;
}

extern "C" PyObject *
socket_connect_return(TInt aError, CSocketAo* aOp);

extern "C" PyObject *
socket_connect(Socket_object *self, PyObject *args)
{
  char* addr;
  int addr_len;
  int port;
  PyObject* c = NULL;
  
  CHECK_NOTCLOSED_NOTWRITEBUSY(self);
  
  if(!PyArg_ParseTuple(args, "(s#i)|O", &addr, &addr_len, &port, &c))
    return NULL;

  if (c == Py_None)
    c = NULL;
  else if (c && !PyCallable_Check(c)) {
    PyErr_BadArgument();
    return NULL;
  }

  CSocketAo* ao = &(self->SE->iWriteAo);
  TSockAddr* address;

  if ((self->ob_proto == KProtocolInetTcp) || (self->ob_proto == KProtocolInetUdp)) { 
    TInt error = set_symbian_inet_addr(ao->iInetAddr, addr, addr_len, port);
    if (error != KErrNone)
      return PySocket_Err(error);
    address = &ao->iInetAddr;
  }
  else if (self->ob_proto == KRFCOMM) {
    set_symbian_bt_addr(ao->iBtAddr, addr, addr_len, port);
    address = &ao->iBtAddr;
  }
  else
    return PySocket_Err("Bad protocol");

  ao->iData[0] = (TAny*)self;
  ao->iCallback = &socket_connect_return;
  ao->iPyCallback = c;

  self->SE->iSocket.Connect(*address, ao->iStatus);
  return ao->HandleReturn((PyObject*)self);
}

extern "C" PyObject *
socket_connect_return(TInt aError, CSocketAo* aOp)
{
  if (aError == KErrNone)
    ((Socket_object*)aOp->iData[0])->ob_is_connected = 1;
  RETURN_SOCKET_ERROR_OR_PYNONE(aError);
}

extern "C" PyObject *
socket_getsockopt(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED(self);

  int level;
  TUint optname;
  int buflen = 0;

  if (!PyArg_ParseTuple(args, "ii|i", &level, &optname, &buflen))
    return NULL;

  if ((optname!=KSoTcpOobInline) && (optname!=KSORecvBuf) &&
      (optname!=KSoReuseAddr) && (optname!=KSOSendBuf) &&
      (optname!=KSockStream) && (optname!=KSockDatagram)) 
    return PySocket_Err("Unsupported option");

  if (buflen == 0) {
    TInt option = 0;
    TInt error = self->SE->iSocket.GetOpt(optname, level, option);
    if (error != KErrNone)
      return PySocket_Err(error);
    return Py_BuildValue("i", option); 
  } else {
    PyObject *option = PyString_FromStringAndSize(NULL, buflen);
    TPtr8 rec_buf((TUint8*)(PyString_AsString(option)), 0, buflen);
    TInt error = self->SE->iSocket.GetOpt(optname, level, rec_buf);
    if (error != KErrNone)
      return PySocket_Err(error);
    if (_PyString_Resize(&option, rec_buf.Size()))
      return NULL;
    else
      return option; 
  }
}

extern "C" PyObject *
socket_listen(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED(self);
  VERIFY_PROTO((self->ob_proto != KProtocolUnknown) &&
	       (self->ob_proto != KProtocolInetUdp));
  int q_sz;
  if (!PyArg_ParseTuple(args, "i", &q_sz))
    return NULL;
  if (q_sz <= 0) 
    return PySocket_Err("Invalid queue size");

  TInt error = self->SE->iSocket.Listen(q_sz);
  RETURN_SOCKET_ERROR_OR_PYNONE(error);
}

extern "C" PyObject *
socket_not_implemented(Socket_object* /*self*/, PyObject* /*args*/)
{
  return PySocket_Err("Not Implemented feature");
}

extern "C" PyObject *
socket_recv_return(TInt aError, CSocketAo* aOp);

extern "C" PyObject *
socket_recv(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED_NOTREADBUSY(self);

  int request = -1;
  TUint flag = 0;
  PyObject* c = NULL;

  if (!PyArg_ParseTuple(args, "i|iO", &request, &flag, &c))
    return NULL;

  if (request < 0) {
    PyErr_SetString(PyExc_ValueError, "negative buffersize in recv");
    return NULL;
  }

  if (flag && 
      (flag != KWaitAll) && 
      (flag != KSockReadPeek) && 
      (flag != (KSockReadPeek|KWaitAll))) 
    return PySocket_Err("Unsupported option");

  if (c == Py_None)
    c = NULL;
  else if (c && !PyCallable_Check(c)) {
    PyErr_BadArgument();
    return NULL;
  }

  PyObject *my_str = PyString_FromStringAndSize(NULL, request);
  if (!my_str)
    return PyErr_NoMemory();
  
  CSocketAo* ao = &(self->SE->iReadAo);
  ao->iData[0] = (TAny*)my_str;
  ao->iData[1] = 0;
  ao->iCallback = &socket_recv_return;
  ao->iPyCallback = c;
  ao->iDataBuf.Set((TUint8*)(PyString_AsString(my_str)),0,request);
  
  if (self->ob_proto == KProtocolInetUdp){
    ao->iData[1] = (TAny*)1;
    self->SE->iSocket.Recv(ao->iDataBuf, (flag & KSockReadPeek), ao->iStatus);
  }
  else if (flag & KWaitAll)
    self->SE->iSocket.Recv(ao->iDataBuf, (flag & KSockReadPeek), ao->iStatus);
  else {
    ao->iData[1] = (TAny*)1;
    self->SE->iSocket.RecvOneOrMore(ao->iDataBuf, (flag & KSockReadPeek), ao->iStatus, ao->iXLen);
  }
  return ao->HandleReturn((PyObject*)self);
}

extern "C" PyObject *
socket_recv_return(TInt aError, CSocketAo* aOp)
{
  PyObject* my_str = (PyObject*)aOp->iData[0];

  if (aError != KErrNone && aError != KErrEof) {
    Py_DECREF(my_str);
    return PySocket_Err(aError);
  }

  if (aOp->iData[1] && (aOp->iXLen() != PyString_Size(my_str)))
    if (_PyString_Resize(&my_str, aOp->iXLen()) == -1)
      return NULL;
  
  return my_str;
}

extern "C" PyObject *
socket_recvfrom_return(TInt aError, CSocketAo* aOp);

extern "C" PyObject *
socket_recvfrom(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED_NOTREADBUSY(self);
  VERIFY_PROTO(self->ob_proto == KProtocolInetUdp);

  int request;
  TUint flag = 0;
  PyObject* c = NULL;

  if (!PyArg_ParseTuple(args, "i|iO", &request, &flag, &c))
    return NULL;
  
  if (flag && (flag != KWaitAll) && (flag != KSockReadPeek)) 
    return PySocket_Err("Unsupported option");

  if (c == Py_None)
    c = NULL;
  else if (c && !PyCallable_Check(c)) {
    PyErr_BadArgument();
    return NULL;
  }

  PyObject *my_str = PyString_FromStringAndSize(NULL, request);
  if (!my_str)
    return PyErr_NoMemory();
  
  TSockAddr* address = new TSockAddr();
  if (!address) {
    Py_DECREF(my_str);
    return PyErr_NoMemory();
  }

  CSocketAo* ao = &(self->SE->iReadAo);
  ao->iData[0] = (TAny*)my_str;
  ao->iData[1] = address;
  ao->iData[2] = self->SE;
  ao->iCallback = &socket_recvfrom_return;
  ao->iPyCallback = c;
  ao->iDataBuf.Set((TUint8*)(PyString_AsString(my_str)),0,request);
  
  self->SE->iSocket.RecvFrom(ao->iDataBuf, *address, flag, ao->iStatus);
  return ao->HandleReturn((PyObject*)self);
}

extern "C" PyObject *
socket_recvfrom_return(TInt aError, CSocketAo* aOp)
{
  PyObject* my_str = (PyObject*)aOp->iData[0];
  TSockAddr* address = (TSockAddr*)aOp->iData[1];
  CSocketEngine* SE = (CSocketEngine*)aOp->iData[2];

  PyObject* r;
  if (aError != KErrNone && aError != KErrEof) {
    Py_DECREF(my_str);
    r = PySocket_Err(aError);
  }
  else {
    if (_PyString_Resize(&my_str, aOp->iDataBuf.Size()))
      r = NULL;
    else {
      SE->iSocket.RemoteName(*address);
      char str[MaxIPAddrLength];
      TUint ipv4=TInetAddr(*address).Address();
      PyOS_snprintf(str, MaxIPAddrLength, "%d.%d.%d.%d",
		    ipv4>>24&0xff, ipv4>>16&0xff, ipv4>>8&0xff, ipv4&0xff);
      r = Py_BuildValue("N(Ni)", my_str,
                        PyString_FromString(str), address->Port());
    }
  }
  delete address;
  return r;
}

extern "C" PyObject *
socket_write_return(TInt aError, CSocketAo* aOp);

extern "C" PyObject *
socket_write(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED_NOTWRITEBUSY(self);

  char* data;
  int data_len;
  int flag = 0;
  PyObject* c = NULL;

  if (!PyArg_ParseTuple(args, "s#|iO", &data, &data_len, &flag, &c))
    return NULL;
  
  if (c == Py_None)
    c = NULL;
  else if (c && !PyCallable_Check(c)) {
    PyErr_BadArgument();
    return NULL;
  }

  CSocketAo* ao = &(self->SE->iWriteAo);
  ao->iData[0] = (TAny*)data_len;
  ao->iCallback = &socket_write_return;
  ao->iPyCallback = c;
  ao->iDataBuf.Set((TUint8*)data, data_len, data_len);
  
  self->SE->iSocket.Send(ao->iDataBuf, flag, ao->iStatus);
  return ao->HandleReturn((PyObject*)self);
}

extern "C" PyObject *
socket_write_return(TInt aError, CSocketAo* aOp)
{
  if (aError != KErrNone)
    return PySocket_Err(aError);

  int data_len = (int)aOp->iData[0];
  return Py_BuildValue("i", data_len); 
}

extern "C" PyObject *
socket_sendto(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED_NOTWRITEBUSY(self);
  VERIFY_PROTO(self->ob_proto == KProtocolInetUdp);

  char* data;
  int data_len;
  char* addr = NULL;
  int addr_len = 0;
  int port = -1;
  int flag = 0;
  PyObject* c = NULL;

  if (!PyArg_ParseTuple(args, "s#i(s#i)|O", &data, &data_len,
                        &flag, &addr, &addr_len, &port, &c)) {
    PyErr_Clear();
    if (!PyArg_ParseTuple(args, "s#(s#i)|O", &data, &data_len,
                          &addr, &addr_len, &port, &c))
      return NULL;
  }

  if (c == Py_None)
    c = NULL;
  else if (c && !PyCallable_Check(c)) {
    PyErr_BadArgument();
    return NULL;
  }

  CSocketAo* ao = &(self->SE->iWriteAo);
  ao->iData[0] = (TAny*)data_len;
  ao->iCallback = &socket_write_return;
  ao->iPyCallback = c;
  ao->iDataBuf.Set((TUint8*)data, data_len, data_len);
  
  TInt error = set_symbian_inet_addr(ao->iInetAddr, addr, addr_len, port);
  if (error != KErrNone)
    return PySocket_Err(error);
  
  self->SE->iSocket.SendTo(ao->iDataBuf, ao->iInetAddr, flag, ao->iStatus);
  return ao->HandleReturn((PyObject*)self);
}

extern "C" PyObject *
socket_setsockopt(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED(self);

  int level;
  TUint opt;
  int val = 0;
  char* val_str = NULL;
  int val_str_len = 0;

  if (!PyArg_ParseTuple(args, "iii", &level, &opt, &val)) {
    PyErr_Clear();
    if (!PyArg_ParseTuple(args, "iis#", &level, &opt, &val_str, &val_str_len))
      return NULL;
  }

  if ((opt!=KSoTcpOobInline) && (opt!=KSORecvBuf) && (opt!=KSoReuseAddr)
      && (opt!=KSOSendBuf) && (opt!=KSockStream) && (opt!=KSockDatagram)) 
    return PySocket_Err("Unsupported option");

  TInt error;

  if (val_str_len == 0)
    error = self->SE->iSocket.SetOpt(opt, level, val);
  else {
    TPtrC8 buf_value((TUint8*)val_str, val_str_len);
    error = self->SE->iSocket.SetOpt(opt, level, buf_value);
  }
  RETURN_SOCKET_ERROR_OR_PYNONE(error);
}

extern "C" PyObject *
socket_shutdown(Socket_object *self, PyObject *args)
{
  CHECK_NOTCLOSED(self);
  if(!self->ob_is_connected)
    return PySocket_Err("Attempt to shut down a disconnected socket");

  int how;
  if (!PyArg_ParseTuple(args, "i", &how))
    return NULL;
  
  RSocket::TShutdown mode = RSocket::ENormal;
  switch (how) {
    //  case 0:
    //    mode = RSocket::EStopInput;
    //    break;
    //  case 1:
    //    mode = RSocket::EStopOutput;
    //    break;
  case 2:
    mode = RSocket::EImmediate;
    break;
  default:
    return PySocket_Err("Only shutdown option 2 supported");
  }

  // do always as 2

  TRequestStatus st;
  self->SE->iSocket.Sh