Perdu dans les pointeurs

Bonjour à tous,

Développeur Pascal, j'ai besoin d'utiliser certaines fonctions écrites en C depuis ce langage. L'une d'entre elles permet de récupérer la liste des processus (sous Mac OS X). Hélas, la structure C décrivant un process est intraduisible en Pascal (enfin elle est sans doute traduisible, mais pas par moi 8O) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
struct extern_proc {
	union {
		struct {
			struct	proc *__p_forw;	/* Doubly-linked run/sleep queue. */
			struct	proc *__p_back;
		} p_st1;
		struct timeval __p_starttime; 	/* process start time */
	} p_un;
#define p_forw p_un.p_st1.__p_forw
#define p_back p_un.p_st1.__p_back
#define p_starttime p_un.__p_starttime
	struct	vmspace *p_vmspace;	/* Address space. */
	struct	sigacts *p_sigacts;	/* Signal actions, state (PROC ONLY). */
	int	p_flag;			/* P_* flags. */
	char	p_stat;			/* S* process status. */
	pid_t	p_pid;			/* Process identifier. */
	pid_t	p_oppid;	 /* Save parent pid during ptrace. XXX */
	int	p_dupfd;	 /* Sideways return value from fdopen. XXX */
	/* Mach related  */
	caddr_t user_stack;	/* where user stack was allocated */
	void	*exit_thread;	/* XXX Which thread is exiting? */
	int		p_debugger;		/* allow to debug */
	boolean_t	sigwait;	/* indication to suspend */
	/* scheduling */
	u_int	p_estcpu;	 /* Time averaged value of p_cpticks. */
	int	p_cpticks;	 /* Ticks of cpu time. */
	fixpt_t	p_pctcpu;	 /* %cpu for this process during p_swtime */
	void	*p_wchan;	 /* Sleep address. */
	char	*p_wmesg;	 /* Reason for sleep. */
	u_int	p_swtime;	 /* Time swapped in or out. */
	u_int	p_slptime;	 /* Time since last blocked. */
	struct	itimerval p_realtimer;	/* Alarm timer. */
	struct	timeval p_rtime;	/* Real time. */
	u_quad_t p_uticks;		/* Statclock hits in user mode. */
	u_quad_t p_sticks;		/* Statclock hits in system mode. */
	u_quad_t p_iticks;		/* Statclock hits processing intr. */
	int	p_traceflag;		/* Kernel trace points. */
	struct	vnode *p_tracep;	/* Trace to vnode. */
	int	p_siglist;		/* DEPRECATED */
	struct	vnode *p_textvp;	/* Vnode of executable. */
	int	p_holdcnt;		/* If non-zero, don't swap. */
	sigset_t p_sigmask;	/* DEPRECATED. */
	sigset_t p_sigignore;	/* Signals being ignored. */
	sigset_t p_sigcatch;	/* Signals being caught by user. */
	u_char	p_priority;	/* Process priority. */
	u_char	p_usrpri;	/* User-priority based on p_cpu and p_nice. */
	char	p_nice;		/* Process "nice" value. */
	char	p_comm[MAXCOMLEN+1];
	struct 	pgrp *p_pgrp;	/* Pointer to process group. */
	struct	user *p_addr;	/* Kernel virtual addr of u-area (PROC ONLY). */
	u_short	p_xstat;	/* Exit status for wait; also stop signal. */
	u_short	p_acflag;	/* Accounting flags. */
	struct	rusage *p_ru;	/* Exit information. XXX */
};
struct kinfo_proc {
        	struct	extern_proc kp_proc;			/* proc structure */
        	struct	eproc {
        		struct	proc *e_paddr;		/* address of proc */
        		struct	session *e_sess;	/* session pointer */
        		struct	_pcred e_pcred;		/* process credentials */
        		struct	_ucred e_ucred;		/* current credentials */
        		struct	 vmspace e_vm;		/* address space */
        		pid_t	e_ppid;			/* parent process id */
        		pid_t	e_pgid;			/* process group id */
        		short	e_jobc;			/* job control counter */
        		dev_t	e_tdev;			/* controlling tty dev */
        		pid_t	e_tpgid;		/* tty process group id */
        		struct	session *e_tsess;	/* tty session pointer */
        #define	WMESGLEN	7
        		char	e_wmesg[WMESGLEN+1];	/* wchan message */
        		segsz_t e_xsize;		/* text size */
        		short	e_xrssize;		/* text rss */
        		short	e_xccount;		/* text references */
        		short	e_xswrss;
        		int32_t	e_flag;
        #define	EPROC_CTTY	0x01	/* controlling tty vnode active */
        #define	EPROC_SLEADER	0x02	/* session leader */
        #define	COMAPT_MAXLOGNAME	12
        		char	e_login[COMAPT_MAXLOGNAME];	/* short setlogin() name */
        		int32_t	e_spare[4];
        	} kp_eproc;
        };

Or, je n'ai besoin que de 2 petites infos: Process ID et Process Name, bref, un char et un int.

Je souhaite donc définir ma propre structure C ne comportant que ces deux info, que je vais remplir à l'aide de la structure abominable d'origine.

J'appelle donc la fonction d'origine (extraite d'une library de l'OS):
GetBSDProcessList(kinfo_proc **procList, size_t *procCount)
où kinfo_proc est le monstre, depuis ma propre fonction
GetBSDProcessListSimple(procsimple **proc, size_t *procCount)
où procsimple est une simplification extrême de kinfo_proc.

Le but est de compiler la chose sous forme d'une library que j'appellerai depuis mon programme Pascal dans lequel j'aurais défini l'équivalent de la structure C simple procsimple.

Dans le code source suivant, j'ai mis des ????? là où je me perds dans les référence avec &, *, ** etc.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/sysctl.h>
 
 
// Monstrueuse structure                                                                             
typedef struct kinfo_proc kinfo_proc;
 
// Structure simplifiée
typedef struct  {
	pid_t	p_pid;			/* Process identifier. */
	char	p_comm[MAXCOMLEN+1];
} procsimple;      
 
 
static int GetBSDProcessList(kinfo_proc **procList, size_t *procCount)
// Returns a list of all BSD processes on the system.  This routine
// allocates the list and puts it in *procList and a count of the
// number of entries in *procCount.  You are responsible for freeing
// this list (use "free" from System framework).
// On success, the function returns 0.
// On error, the function returns a BSD errno value.
{
    int                 err;
    kinfo_proc *        result;
    bool                done;
    static const int    name[] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0 };
    // Declaring name as const requires us to cast it when passing it to
    // sysctl because the prototype doesn't include the const modifier.
    size_t              length;
 
    assert( procList != NULL);
    assert(*procList == NULL);
    assert(procCount != NULL);
 
    *procCount = 0;
 
    // We start by calling sysctl with result == NULL and length == 0.
    // That will succeed, and set length to the appropriate length.
    // We then allocate a buffer of that size and call sysctl again
    // with that buffer.  If that succeeds, we're done.  If that fails
    // with ENOMEM, we have to throw away our buffer and loop.  Note
    // that the loop causes use to call sysctl with NULL again; this
    // is necessary because the ENOMEM failure case sets length to
    // the amount of data returned, not the amount of data that
    // could have been returned.
 
    result = NULL;
    done = false;
    do {
        assert(result == NULL);
 
        // Call sysctl with a NULL buffer.
 
        length = 0;
        err = sysctl( (int *) name, (sizeof(name) / sizeof(*name)) - 1,
					 NULL, &length,
					 NULL, 0);
        if (err == -1) {
            err = errno;
        }
 
        // Allocate an appropriately sized buffer based on the results
        // from the previous call.
 
        if (err == 0) {
            result = malloc(length);
            if (result == NULL) {
                err = ENOMEM;
            }
        }
 
        // Call sysctl again with the new buffer.  If we get an ENOMEM
        // error, toss away our buffer and start again.
 
        if (err == 0) {
            err = sysctl( (int *) name, (sizeof(name) / sizeof(*name)) - 1,
						 result, &length,
						 NULL, 0);
            if (err == -1) {
                err = errno;
            }
            if (err == 0) {
                done = true;
            } else if (err == ENOMEM) {
                assert(result != NULL);
                free(result);
                result = NULL;
                err = 0;
            }
        }
    } while (err == 0 && ! done);
 
    // Clean up and establish post conditions.
 
    if (err != 0 && result != NULL) {
        free(result);
        result = NULL;
    }
    *procList = result;
    if (err == 0) {
        *procCount = length / sizeof(kinfo_proc);
    }
 
    assert( (err == 0) == (*procList != NULL) );
 
	return err;
}
 
 
static int GetBSDProcessListSimple(procsimple **proc, size_t *procCount)
{
	int err, i;
	kinfo_proc *       process;
	size_t             ProcCount;
 
    err = GetBSDProcessList(&process, &ProcCount);
	for (i=0; i<= ProcCount; i++) {
 
            ?????
            // Que faire ici ? Comment accéder aux membre p_pid et p_comm
           // de process pour les copier dans procsimple ? 
 
	}				   
	return err;
};

Un grand merci d'avance,
André.

Est-ce que ce type de code fonctionnerait ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
static int GetBSDProcessListSimple(procsimple ** proclistsimple, size_t *procCount)
{
	int err, i, j;
	kinfo_proc *       process;
	size_t             ProcCount;
 
    err = GetBSDProcessList(&process, &ProcCount);
	*proclistsimple = malloc(ProcCount * sizeof(procsimple));
	for (i=0; i< ProcCount; i++) {
		//(*(*proclistsimple + i)).p_pid; 
		//(*(process + i)).kp_proc.p_pid;
 
		(*proclistsimple)[i].p_pid = process[i].kp_proc.p_pid;
		for (j=0; j<MAXCOMLEN+1; j++) {
			(*proclistsimple)[i].p_comm[j] = process[i].kp_proc.p_comm[j];
		}
	}			
	free(process);
	return err;
};

process est un tableau, alloué dynamiquement par GetBSDProcessList(), de ProcCount éléments de type kinfo_proc.
Chaque élément est accessible par process[i] pour 0 <= i < ProcCount (attention, strictement inférieur).

p_pid et p_comm sont des membres de la stucture extern_proc inclue dans la stucture kinfo_proc. Cette structure extern_proc est accessible par process[i].kp_proc et ses champs par process[i].kp_proc.p_pid et process[i].kp_proc.p_comm