gdiplus: Allow null-terminated strings in GdipDrawString.
[wine] / server / procfs.c
1 /*
2  * Server-side /proc support for Solaris
3  *
4  * Copyright (C) 2007 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include "config.h"
22
23 #include <assert.h>
24 #include <errno.h>
25 #include <fcntl.h>
26 #include <stdio.h>
27 #include <signal.h>
28 #include <stdarg.h>
29 #include <sys/types.h>
30 #include <unistd.h>
31
32 #include "ntstatus.h"
33 #define WIN32_NO_STATUS
34 #include "winternl.h"
35
36 #include "file.h"
37 #include "process.h"
38 #include "thread.h"
39
40 #ifdef USE_PROCFS
41
42 #include <procfs.h>
43
44 static int open_proc_as( struct process *process, int flags )
45 {
46     char buffer[32];
47     int fd;
48
49     sprintf( buffer, "/proc/%u/as", process->unix_pid );
50     if ((fd = open( buffer, flags )) == -1) file_set_error();
51     return fd;
52 }
53
54 static int open_proc_lwpctl( struct thread *thread )
55 {
56     char buffer[48];
57     int fd;
58
59     sprintf( buffer, "/proc/%u/lwp/%u/lwpctl", thread->unix_pid, thread->unix_tid );
60     if ((fd = open( buffer, O_WRONLY )) == -1) file_set_error();
61     return fd;
62 }
63
64
65 /* handle a SIGCHLD signal */
66 void sigchld_callback(void)
67 {
68     assert( 0 );  /* should only be called when using ptrace */
69 }
70
71 /* initialize the process tracing mechanism */
72 void init_tracing_mechanism(void)
73 {
74     /* no initialization needed */
75 }
76
77 /* initialize the per-process tracing mechanism */
78 void init_process_tracing( struct process *process )
79 {
80     /* setup is done on-demand */
81 }
82
83 /* terminate the per-process tracing mechanism */
84 void finish_process_tracing( struct process *process )
85 {
86 }
87
88 /* send a Unix signal to a specific thread */
89 int send_thread_signal( struct thread *thread, int sig )
90 {
91     int fd = open_proc_lwpctl( thread );
92     long kill[2];
93     ssize_t ret;
94
95     if (fd == -1) return 0;
96
97     kill[0] = PCKILL;
98     kill[1] = sig;
99     ret = write( fd, kill, sizeof(kill) );
100     close( fd );
101     return (ret == sizeof(kill));
102 }
103
104 /* read data from a process memory space */
105 int read_process_memory( struct process *process, const void *ptr, size_t size, char *dest )
106 {
107     ssize_t ret;
108     int fd = open_proc_as( process, O_RDONLY );
109
110     if (fd == -1) return 0;
111
112     ret = pread( fd, dest, size, (off_t)ptr );
113     close( fd );
114     if (ret == size) return 1;
115
116     if (ret == -1) file_set_error();
117     else set_error( STATUS_ACCESS_VIOLATION );
118     return 0;
119 }
120
121 /* write data to a process memory space */
122 int write_process_memory( struct process *process, void *ptr, size_t size, const char *src )
123 {
124     ssize_t ret;
125     int fd = open_proc_as( process, O_WRONLY );
126
127     if (fd == -1) return 0;
128
129     ret = pwrite( fd, src, size, (off_t)ptr );
130     close( fd );
131     if (ret == size) return 1;
132
133     if (ret == -1) file_set_error();
134     else set_error( STATUS_ACCESS_VIOLATION );
135     return 0;
136 }
137
138 /* retrieve an LDT selector entry */
139 void get_selector_entry( struct thread *thread, int entry, unsigned int *base,
140                          unsigned int *limit, unsigned char *flags )
141 {
142     ssize_t ret;
143     off_t pos = (off_t)thread->process->ldt_copy;
144     int fd = open_proc_as( thread->process, O_RDONLY );
145
146     if (fd == -1) return;
147
148     ret = pread( fd, base, sizeof(*base), pos + entry*sizeof(int) );
149     if (ret != sizeof(*base)) goto error;
150     ret = pread( fd, limit, sizeof(*limit), pos + (8192 + entry)*sizeof(int) );
151     if (ret != sizeof(*limit)) goto error;
152     ret = pread( fd, flags, sizeof(*flags), pos + 2*8192*sizeof(int) + entry );
153     if (ret != sizeof(*flags)) goto error;
154     close( fd );
155     return;
156
157 error:
158     if (ret == -1) file_set_error();
159     else set_error( STATUS_ACCESS_VIOLATION );
160     close( fd );
161 }
162
163 /* retrieve the thread registers */
164 void get_thread_context( struct thread *thread, CONTEXT *context, unsigned int flags )
165 {
166     /* all other regs are handled on the client side */
167     assert( (flags | CONTEXT_i386) == CONTEXT_DEBUG_REGISTERS );
168
169     /* FIXME: get debug registers */
170 }
171
172 /* set the thread registers */
173 void set_thread_context( struct thread *thread, const CONTEXT *context, unsigned int flags )
174 {
175     /* all other regs are handled on the client side */
176     assert( (flags | CONTEXT_i386) == CONTEXT_DEBUG_REGISTERS );
177
178     /* FIXME: set debug registers */
179 }
180
181 #endif /* USE_PROCFS */