Using SWIG to Control, Prototype, and Debug C Programs with Python

Abstract

Introduction

Introducing SWIG

static PyObject *wrap_getenv(PyObject *self, PyObject *args) {
         char * result;
         char * arg0;
         if(!PyArg_ParseTuple(args, "s",&arg0))
                 return NULL;
         result = getenv(arg0);
         return Py_BuildValue("s", result);
}

Previous work

A SWIG example

// socket.i
// SWIG Interface file to play with some sockets
%init sock          // Name of our module
%{
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

/* Set some values in the sockaddr_in structure */
struct sockaddr *new_sockaddr_in(short family, unsigned long hostid, int port) {
        struct sockaddr_in *addr;
        addr = (struct sockaddr_in *) malloc(sizeof(struct sockaddr_in));
        bzero((char *) addr, sizeof(struct sockaddr_in));
        addr->sin_family = family;
        addr->sin_addr.s_addr = hostid;
        addr->sin_port = htons(port);
        return (struct sockaddr *) addr;
}
/* Get host address, but return as a string instead of hostent */
char *my_gethostbyname(char *hostname) {
        struct hostent *h;
        h = gethostbyname(hostname);
        if (h) return h->h_name;
        else return "";
}
%}

// Add these constants
enum {AF_UNIX, AF_INET, SOCK_STREAM, SOCK_DGRAM, SOCK_RAW,
      IPPROTO_UDP, IPPROTO_TCP, INADDR_ANY};

#define  SIZEOF_SOCKADDR  sizeof(struct sockaddr)

// Wrap these functions 
int socket(int family, int type, int protocol);
int bind(int sockfd, struct sockaddr *myaddr, int addrlen);
int connect(int sockfd, struct sockaddr *servaddr, int addrlen);
int listen(int sockfd, int backlog);
int accept(int sockfd, struct sockaddr *peer, %val int *addrlen);
int close(int fd);
struct sockaddr *new_sockaddr_in(short family, unsigned long, int port);
%name gethostbyname { char *my_gethostbyname(char *); }
unsigned long inet_addr(const char *ip);

%include unixio.i

• The module name is specified with the %init directive.
• Header files and supporting C code is placed in %{,%} .
• Special support functions may be necessary. For example, new_sockaddr_in() creates a new struct sockaddr_in type and sets some of its values.
• Constants are created with enum or #define.
• Functions can take most C basic datatypes as well as pointers to complex types.
• Functions can be renamed with the %name directive.
• The %val directive forces a function argument to be called by value.
• The %include directive can be used to include other SWIG interface files. In this case, the file unixio.i might look like the following :

  // File : unixio.i 
  // Some file I/O and memory functions
  %{
  %}
  int read(int fd, void *buffer, int n);
  int write(int fd, void *buffer, int n);
  typedef unsigned int size_t;
  void *malloc(size_t nbytes);
  

• Since interface files can include other interface files, it can be very easy to build up libraries and collections of useful functions.
• typedef can be used to provide mapping between datatypes.
• C and C++ comments are allowed and like C, SWIG ignores whitespace.

Building a Python module

unix > wrap -python socket.i
unix > gcc -c socket_wrap.c -I/usr/local/include/Py
unix > ld -G socket_wrap.o -lsocket -lnsl -o sockmodule.so

A sample Python script

# Echo server program using SWIG module
from sock import *
PORT = 5000
sockfd = socket(AF_INET, SOCK_STREAM, 0)
if sockfd < 0:
        raise IOError, 'server : unable to open stream socket'
addr = new_sockaddr_in(AF_INET,INADDR_ANY,PORT)
if (bind(sockfd, addr, SIZEOF_SOCKADDR)) < 0 :
        raise IOError, 'server : unable to bind local address'
listen(sockfd,5)
client_addr = new_sockaddr_in(AF_INET, 0, 0)
newsockfd = accept(sockfd, client_addr, SIZEOF_SOCKADDR)
buffer = malloc(1024)
while 1:
        nbytes = read(newsockfd, buffer, 1024)
        if nbytes > 0 :
                write(newsockfd,buffer,nbytes)
        else : break
close(newsockfd)
close(sockfd)

Pointers and run-time type checking

unix > python
Python 1.3 (Apr 12 1996)  [GCC 2.5.8]
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> from sock import *
>>> sockfd = socket(AF_INET, SOCK_STREAM,0);
>>> buffer = malloc(8192);
>>> bind(sockfd,buffer,SIZEOF_SOCKADDR);
Traceback (innermost last):
  File "", line 1, in ?
TypeError: Type error in argument 2 of bind. Expected _struct_sockaddr_p.
>>> 

Comparison with a real Python module

# Echo client program
from socket import *
HOST = 'tjaze.lanl.gov'
PORT = 5000
s = socket(AF_INET, SOCK_STREAM)
s.connect(HOST,PORT)
s.send('Hello world')
data = s.recv(1024)
s.close()
print 'Received', `data`

Controlling C programs

Prototyping and Debugging

Living dangerously with datatypes

// tcl.i
// Wrap Tcl's C interface
%init tcl
%{
#include <tcl.h>
%}

Tcl_Interp *Tcl_CreateInterp(void);
void        Tcl_DeleteInterp(Tcl_Interp *interp);
int         Tcl_Eval(Tcl_Interp *interp, char *script);
int         Tcl_EvalFile(Tcl_Interp *interp, char *file);

unix > python
Python 1.3 (Mar 26 1996)  [GCC 2.7.0]
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>> import tcl
>>> interp = tcl.Tcl_CreateInterp();
>>> tcl.Tcl_Eval(interp,"for {set i 0} {$i < 5} {incr i 1} {puts $i}");
0
1
2
3
4
0
>>>

Limitations

Limitations in the Python implementation

Summary and future work

Acknowledgments

References