← Back to branch summary

~ubuntu-branches/ubuntu/lucid/squeak-vm/lucid

« back to all changes in this revision

Viewing changes to platforms/unix/src/vm/intplugins/SecurityPlugin/SecurityPlugin.c

  • Committer: Bazaar Package Importer
  • Author(s): Oliver Grawert
  • Date: 2005-07-15 11:44:08 UTC
  • Revision ID: james.westby@ubuntu.com-20050715114408-lgcvpntigab09l00
Tags: upstream-3.7.7
Import upstream version 3.7.7

Show diffs side-by-side

added added

removed removed

Lines of Context:
platforms/unix/src/vm/intplugins/SecurityPlugin/SecurityPlugin.c
 
1
/* Automatically generated from Squeak on #(19 March 2005 10:09:03 am) */
 
2
 
 
3
#include <math.h>
 
4
#include <stdio.h>
 
5
#include <stdlib.h>
 
6
#include <string.h>
 
7
#include <time.h>
 
8
 
 
9
/* Default EXPORT macro that does nothing (see comment in sq.h): */
 
10
#define EXPORT(returnType) returnType
 
11
 
 
12
/* Do not include the entire sq.h file but just those parts needed. */
 
13
/*  The virtual machine proxy definition */
 
14
#include "sqVirtualMachine.h"
 
15
/* Configuration options */
 
16
#include "sqConfig.h"
 
17
/* Platform specific definitions */
 
18
#include "sqPlatformSpecific.h"
 
19
 
 
20
#define true 1
 
21
#define false 0
 
22
#define null 0  /* using 'null' because nil is predefined in Think C */
 
23
#ifdef SQUEAK_BUILTIN_PLUGIN
 
24
#undef EXPORT
 
25
// was #undef EXPORT(returnType) but screws NorCroft cc
 
26
#define EXPORT(returnType) static returnType
 
27
#endif
 
28
#include "SecurityPlugin.h"
 
29
 
 
30
/* memory access macros */
 
31
#define byteAt(i) (*((unsigned char *) (i)))
 
32
#define byteAtput(i, val) (*((unsigned char *) (i)) = val)
 
33
#define longAt(i) (*((int *) (i)))
 
34
#define longAtput(i, val) (*((int *) (i)) = val)
 
35
 
 
36
 
 
37
/*** Constants ***/
 
38
 
 
39
/*** Function Prototypes ***/
 
40
#pragma export on
 
41
EXPORT(const char*) getModuleName(void);
 
42
#pragma export off
 
43
static int halt(void);
 
44
#pragma export on
 
45
EXPORT(int) initialiseModule(void);
 
46
#pragma export off
 
47
static int msg(char *s);
 
48
#pragma export on
 
49
EXPORT(int) primitiveCanWriteImage(void);
 
50
EXPORT(int) primitiveDisableImageWrite(void);
 
51
EXPORT(int) primitiveGetSecureUserDirectory(void);
 
52
EXPORT(int) primitiveGetUntrustedUserDirectory(void);
 
53
EXPORT(int) secCanListenOnPort(int socket, int port);
 
54
EXPORT(int) secCanConnectToPort(int addr, int port);
 
55
EXPORT(int) secCanCreateSocketOfType(int netType, int socketType);
 
56
EXPORT(int) secCanCreatePathOfSize(char * dirName, int dirNameSize);
 
57
EXPORT(int) secCanDeleteFileOfSize(char * fileName, int fileNameSize);
 
58
EXPORT(int) secCanDeletePathOfSize(char * dirName, int dirNameSize);
 
59
EXPORT(int) secCanGetFileTypeOfSize(char * fileName, int fileNameSize);
 
60
EXPORT(int) secCanListPathOfSize(char * pathName, int pathNameSize);
 
61
EXPORT(int) secCanOpenAsyncFileOfSizeWritable(char * fileName, int fileNameSize, int writeFlag);
 
62
EXPORT(int) secCanOpenFileOfSizeWritable(char * fileName, int fileNameSize, int writeFlag);
 
63
EXPORT(int) secCanRenameFileOfSize(char * fileName, int fileNameSize);
 
64
EXPORT(int) secCanRenameImage(void);
 
65
EXPORT(int) secCanSetFileTypeOfSize(char * fileName, int fileNameSize);
 
66
EXPORT(int) secCanWriteImage(void);
 
67
EXPORT(int) secDisableFileAccess(void);
 
68
EXPORT(int) secDisableSocketAccess(void);
 
69
EXPORT(int) secHasFileAccess(void);
 
70
EXPORT(int) secHasSocketAccess(void);
 
71
EXPORT(int) setInterpreter(struct VirtualMachine* anInterpreter);
 
72
#pragma export off
 
73
/*** Variables ***/
 
74
 
 
75
#ifdef SQUEAK_BUILTIN_PLUGIN
 
76
extern
 
77
#endif
 
78
struct VirtualMachine* interpreterProxy;
 
79
static const char *moduleName =
 
80
#ifdef SQUEAK_BUILTIN_PLUGIN
 
81
        "SecurityPlugin 19 March 2005 (i)"
 
82
#else
 
83
        "SecurityPlugin 19 March 2005 (e)"
 
84
#endif
 
85
;
 
86
 
 
87
 
 
88
 
 
89
/*      Note: This is hardcoded so it can be run from Squeak.
 
90
        The module name is used for validating a module *after*
 
91
        it is loaded to check if it does really contain the module
 
92
        we're thinking it contains. This is important! */
 
93
 
 
94
EXPORT(const char*) getModuleName(void) {
 
95
        return moduleName;
 
96
}
 
97
 
 
98
static int halt(void) {
 
99
        ;
 
100
}
 
101
 
 
102
EXPORT(int) initialiseModule(void) {
 
103
        return ioInitSecurity();
 
104
}
 
105
 
 
106
static int msg(char *s) {
 
107
        fprintf(stderr, "\n%s: %s", moduleName, s);
 
108
}
 
109
 
 
110
EXPORT(int) primitiveCanWriteImage(void) {
 
111
        interpreterProxy->pop(1);
 
112
        interpreterProxy->pushBool(ioCanWriteImage());
 
113
}
 
114
 
 
115
EXPORT(int) primitiveDisableImageWrite(void) {
 
116
        ioDisableImageWrite();
 
117
        if (!(interpreterProxy->failed())) {
 
118
                interpreterProxy->pop(1);
 
119
        }
 
120
}
 
121
 
 
122
 
 
123
/*      Primitive. Return the secure directory for the current user. */
 
124
 
 
125
EXPORT(int) primitiveGetSecureUserDirectory(void) {
 
126
    int i;
 
127
    char * dirName;
 
128
    int dirLen;
 
129
    int dirOop;
 
130
    char * dirPtr;
 
131
 
 
132
        dirName = ioGetSecureUserDirectory();
 
133
        if ((dirName == null) || (interpreterProxy->failed())) {
 
134
                return interpreterProxy->primitiveFail();
 
135
        }
 
136
        dirLen = strlen(dirName);
 
137
        dirOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), dirLen);
 
138
        if (interpreterProxy->failed()) {
 
139
                return null;
 
140
        }
 
141
        dirPtr = interpreterProxy->firstIndexableField(dirOop);
 
142
        for (i = 0; i <= (dirLen - 1); i += 1) {
 
143
                dirPtr[i] = (dirName[i]);
 
144
        }
 
145
        interpreterProxy->pop(1);
 
146
        interpreterProxy->push(dirOop);
 
147
}
 
148
 
 
149
 
 
150
/*      Primitive. Return the untrusted user directory name. */
 
151
 
 
152
EXPORT(int) primitiveGetUntrustedUserDirectory(void) {
 
153
    int i;
 
154
    char * dirName;
 
155
    int dirLen;
 
156
    int dirOop;
 
157
    char * dirPtr;
 
158
 
 
159
        dirName = ioGetUntrustedUserDirectory();
 
160
        if ((dirName == null) || (interpreterProxy->failed())) {
 
161
                return interpreterProxy->primitiveFail();
 
162
        }
 
163
        dirLen = strlen(dirName);
 
164
        dirOop = interpreterProxy->instantiateClassindexableSize(interpreterProxy->classString(), dirLen);
 
165
        if (interpreterProxy->failed()) {
 
166
                return null;
 
167
        }
 
168
        dirPtr = interpreterProxy->firstIndexableField(dirOop);
 
169
        for (i = 0; i <= (dirLen - 1); i += 1) {
 
170
                dirPtr[i] = (dirName[i]);
 
171
        }
 
172
        interpreterProxy->pop(1);
 
173
        interpreterProxy->push(dirOop);
 
174
}
 
175
 
 
176
EXPORT(int) secCanListenOnPort(int socket, int port) {
 
177
        return ioCanListenOnPort(socket, port);
 
178
}
 
179
 
 
180
EXPORT(int) secCanConnectToPort(int addr, int port) {
 
181
        return ioCanConnectToPort(addr, port);
 
182
}
 
183
 
 
184
EXPORT(int) secCanCreateSocketOfType(int netType, int socketType) {
 
185
        return ioCanCreateSocketOfType(netType, socketType);
 
186
}
 
187
 
 
188
EXPORT(int) secCanCreatePathOfSize(char * dirName, int dirNameSize) {
 
189
        return ioCanCreatePathOfSize(dirName, dirNameSize);
 
190
}
 
191
 
 
192
EXPORT(int) secCanDeleteFileOfSize(char * fileName, int fileNameSize) {
 
193
        return ioCanDeleteFileOfSize(fileName, fileNameSize);
 
194
}
 
195
 
 
196
EXPORT(int) secCanDeletePathOfSize(char * dirName, int dirNameSize) {
 
197
        return ioCanDeletePathOfSize(dirName, dirNameSize);
 
198
}
 
199
 
 
200
EXPORT(int) secCanGetFileTypeOfSize(char * fileName, int fileNameSize) {
 
201
        return ioCanGetFileTypeOfSize(fileName, fileNameSize);
 
202
}
 
203
 
 
204
EXPORT(int) secCanListPathOfSize(char * pathName, int pathNameSize) {
 
205
        return ioCanListPathOfSize(pathName, pathNameSize);
 
206
}
 
207
 
 
208
EXPORT(int) secCanOpenAsyncFileOfSizeWritable(char * fileName, int fileNameSize, int writeFlag) {
 
209
        return ioCanOpenAsyncFileOfSizeWritable(fileName, fileNameSize, writeFlag);
 
210
}
 
211
 
 
212
EXPORT(int) secCanOpenFileOfSizeWritable(char * fileName, int fileNameSize, int writeFlag) {
 
213
        return ioCanOpenFileOfSizeWritable(fileName, fileNameSize, writeFlag);
 
214
}
 
215
 
 
216
EXPORT(int) secCanRenameFileOfSize(char * fileName, int fileNameSize) {
 
217
        return ioCanRenameFileOfSize(fileName, fileNameSize);
 
218
}
 
219
 
 
220
EXPORT(int) secCanRenameImage(void) {
 
221
        return ioCanRenameImage();
 
222
}
 
223
 
 
224
EXPORT(int) secCanSetFileTypeOfSize(char * fileName, int fileNameSize) {
 
225
        return ioCanSetFileTypeOfSize(fileName, fileNameSize);
 
226
}
 
227
 
 
228
EXPORT(int) secCanWriteImage(void) {
 
229
        return ioCanWriteImage();
 
230
}
 
231
 
 
232
EXPORT(int) secDisableFileAccess(void) {
 
233
        return ioDisableFileAccess();
 
234
}
 
235
 
 
236
EXPORT(int) secDisableSocketAccess(void) {
 
237
        return ioDisableSocketAccess();
 
238
}
 
239
 
 
240
EXPORT(int) secHasFileAccess(void) {
 
241
        return ioHasFileAccess();
 
242
}
 
243
 
 
244
EXPORT(int) secHasSocketAccess(void) {
 
245
        return ioHasSocketAccess();
 
246
}
 
247
 
 
248
 
 
249
/*      Note: This is coded so that is can be run from Squeak. */
 
250
 
 
251
EXPORT(int) setInterpreter(struct VirtualMachine* anInterpreter) {
 
252
    int ok;
 
253
 
 
254
        interpreterProxy = anInterpreter;
 
255
        ok = interpreterProxy->majorVersion() == VM_PROXY_MAJOR;
 
256
        if (ok == 0) {
 
257
                return 0;
 
258
        }
 
259
        ok = interpreterProxy->minorVersion() >= VM_PROXY_MINOR;
 
260
        return ok;
 
261
}
 
262
 
 
263
 
 
264
#ifdef SQUEAK_BUILTIN_PLUGIN
 
265
 
 
266
 
 
267
void* SecurityPlugin_exports[][3] = {
 
268
        {"SecurityPlugin", "secCanSetFileTypeOfSize", (void*)secCanSetFileTypeOfSize},
 
269
        {"SecurityPlugin", "secCanCreateSocketOfType", (void*)secCanCreateSocketOfType},
 
270
        {"SecurityPlugin", "secHasSocketAccess", (void*)secHasSocketAccess},
 
271
        {"SecurityPlugin", "secCanWriteImage", (void*)secCanWriteImage},
 
272
        {"SecurityPlugin", "secCanGetFileTypeOfSize", (void*)secCanGetFileTypeOfSize},
 
273
        {"SecurityPlugin", "initialiseModule", (void*)initialiseModule},
 
274
        {"SecurityPlugin", "secCanListPathOfSize", (void*)secCanListPathOfSize},
 
275
        {"SecurityPlugin", "getModuleName", (void*)getModuleName},
 
276
        {"SecurityPlugin", "secCanRenameFileOfSize", (void*)secCanRenameFileOfSize},
 
277
        {"SecurityPlugin", "setInterpreter", (void*)setInterpreter},
 
278
        {"SecurityPlugin", "secCanListenOnPort", (void*)secCanListenOnPort},
 
279
        {"SecurityPlugin", "secCanRenameImage", (void*)secCanRenameImage},
 
280
        {"SecurityPlugin", "secHasFileAccess", (void*)secHasFileAccess},
 
281
        {"SecurityPlugin", "secCanConnectToPort", (void*)secCanConnectToPort},
 
282
        {"SecurityPlugin", "primitiveDisableImageWrite", (void*)primitiveDisableImageWrite},
 
283
        {"SecurityPlugin", "secCanCreatePathOfSize", (void*)secCanCreatePathOfSize},
 
284
        {"SecurityPlugin", "secDisableFileAccess", (void*)secDisableFileAccess},
 
285
        {"SecurityPlugin", "secDisableSocketAccess", (void*)secDisableSocketAccess},
 
286
        {"SecurityPlugin", "secCanOpenFileOfSizeWritable", (void*)secCanOpenFileOfSizeWritable},
 
287
        {"SecurityPlugin", "primitiveCanWriteImage", (void*)primitiveCanWriteImage},
 
288
        {"SecurityPlugin", "primitiveGetUntrustedUserDirectory", (void*)primitiveGetUntrustedUserDirectory},
 
289
        {"SecurityPlugin", "primitiveGetSecureUserDirectory", (void*)primitiveGetSecureUserDirectory},
 
290
        {"SecurityPlugin", "secCanDeletePathOfSize", (void*)secCanDeletePathOfSize},
 
291
        {"SecurityPlugin", "secCanDeleteFileOfSize", (void*)secCanDeleteFileOfSize},
 
292
        {"SecurityPlugin", "secCanOpenAsyncFileOfSizeWritable", (void*)secCanOpenAsyncFileOfSizeWritable},
 
293
        {NULL, NULL, NULL}
 
294
};
 
295
 
 
296
 
 
297
#endif /* ifdef SQ_BUILTIN_PLUGIN */
 
298