OLD | NEW |
1 /* dso_vms.c -*- mode:C; c-file-style: "eay" -*- */ | 1 /* dso_vms.c -*- mode:C; c-file-style: "eay" -*- */ |
2 /* Written by Richard Levitte (richard@levitte.org) for the OpenSSL | 2 /* Written by Richard Levitte (richard@levitte.org) for the OpenSSL |
3 * project 2000. | 3 * project 2000. |
4 */ | 4 */ |
5 /* ==================================================================== | 5 /* ==================================================================== |
6 * Copyright (c) 2000 The OpenSSL Project. All rights reserved. | 6 * Copyright (c) 2000 The OpenSSL Project. All rights reserved. |
7 * | 7 * |
8 * Redistribution and use in source and binary forms, with or without | 8 * Redistribution and use in source and binary forms, with or without |
9 * modification, are permitted provided that the following conditions | 9 * modification, are permitted provided that the following conditions |
10 * are met: | 10 * are met: |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
61 #include <errno.h> | 61 #include <errno.h> |
62 #include "cryptlib.h" | 62 #include "cryptlib.h" |
63 #include <openssl/dso.h> | 63 #include <openssl/dso.h> |
64 #ifdef OPENSSL_SYS_VMS | 64 #ifdef OPENSSL_SYS_VMS |
65 #pragma message disable DOLLARID | 65 #pragma message disable DOLLARID |
66 #include <rms.h> | 66 #include <rms.h> |
67 #include <lib$routines.h> | 67 #include <lib$routines.h> |
68 #include <stsdef.h> | 68 #include <stsdef.h> |
69 #include <descrip.h> | 69 #include <descrip.h> |
70 #include <starlet.h> | 70 #include <starlet.h> |
| 71 #include "vms_rms.h" |
71 #endif | 72 #endif |
72 | 73 |
| 74 /* Some compiler options may mask the declaration of "_malloc32". */ |
| 75 #if __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE |
| 76 # if __INITIAL_POINTER_SIZE == 64 |
| 77 # pragma pointer_size save |
| 78 # pragma pointer_size 32 |
| 79 void * _malloc32 (__size_t); |
| 80 # pragma pointer_size restore |
| 81 # endif /* __INITIAL_POINTER_SIZE == 64 */ |
| 82 #endif /* __INITIAL_POINTER_SIZE && defined _ANSI_C_SOURCE */ |
| 83 |
| 84 |
73 #ifndef OPENSSL_SYS_VMS | 85 #ifndef OPENSSL_SYS_VMS |
74 DSO_METHOD *DSO_METHOD_vms(void) | 86 DSO_METHOD *DSO_METHOD_vms(void) |
75 { | 87 { |
76 return NULL; | 88 return NULL; |
77 } | 89 } |
78 #else | 90 #else |
79 #pragma message disable DOLLARID | 91 #pragma message disable DOLLARID |
80 | 92 |
81 static int vms_load(DSO *dso); | 93 static int vms_load(DSO *dso); |
82 static int vms_unload(DSO *dso); | 94 static int vms_unload(DSO *dso); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
114 /* On VMS, the only "handle" is the file name. LIB$FIND_IMAGE_SYMBOL depends | 126 /* On VMS, the only "handle" is the file name. LIB$FIND_IMAGE_SYMBOL depends |
115 * on the reference to the file name being the same for all calls regarding | 127 * on the reference to the file name being the same for all calls regarding |
116 * one shared image, so we'll just store it in an instance of the following | 128 * one shared image, so we'll just store it in an instance of the following |
117 * structure and put a pointer to that instance in the meth_data stack. | 129 * structure and put a pointer to that instance in the meth_data stack. |
118 */ | 130 */ |
119 typedef struct dso_internal_st | 131 typedef struct dso_internal_st |
120 { | 132 { |
121 /* This should contain the name only, no directory, | 133 /* This should contain the name only, no directory, |
122 * no extension, nothing but a name. */ | 134 * no extension, nothing but a name. */ |
123 struct dsc$descriptor_s filename_dsc; | 135 struct dsc$descriptor_s filename_dsc; |
124 » char filename[FILENAME_MAX+1]; | 136 » char filename[ NAMX_MAXRSS+ 1]; |
125 /* This contains whatever is not in filename, if needed. | 137 /* This contains whatever is not in filename, if needed. |
126 * Normally not defined. */ | 138 * Normally not defined. */ |
127 struct dsc$descriptor_s imagename_dsc; | 139 struct dsc$descriptor_s imagename_dsc; |
128 » char imagename[FILENAME_MAX+1]; | 140 » char imagename[ NAMX_MAXRSS+ 1]; |
129 } DSO_VMS_INTERNAL; | 141 } DSO_VMS_INTERNAL; |
130 | 142 |
131 | |
132 DSO_METHOD *DSO_METHOD_vms(void) | 143 DSO_METHOD *DSO_METHOD_vms(void) |
133 { | 144 { |
134 return(&dso_meth_vms); | 145 return(&dso_meth_vms); |
135 } | 146 } |
136 | 147 |
137 static int vms_load(DSO *dso) | 148 static int vms_load(DSO *dso) |
138 { | 149 { |
139 void *ptr = NULL; | 150 void *ptr = NULL; |
140 /* See applicable comments in dso_dl.c */ | 151 /* See applicable comments in dso_dl.c */ |
141 char *filename = DSO_convert_filename(dso, NULL); | 152 char *filename = DSO_convert_filename(dso, NULL); |
142 » DSO_VMS_INTERNAL *p; | 153 |
| 154 /* Ensure 32-bit pointer for "p", and appropriate malloc() function. */ |
| 155 #if __INITIAL_POINTER_SIZE == 64 |
| 156 # define DSO_MALLOC _malloc32 |
| 157 # pragma pointer_size save |
| 158 # pragma pointer_size 32 |
| 159 #else /* __INITIAL_POINTER_SIZE == 64 */ |
| 160 # define DSO_MALLOC OPENSSL_malloc |
| 161 #endif /* __INITIAL_POINTER_SIZE == 64 [else] */ |
| 162 |
| 163 » DSO_VMS_INTERNAL *p = NULL; |
| 164 |
| 165 #if __INITIAL_POINTER_SIZE == 64 |
| 166 # pragma pointer_size restore |
| 167 #endif /* __INITIAL_POINTER_SIZE == 64 */ |
| 168 |
143 const char *sp1, *sp2; /* Search result */ | 169 const char *sp1, *sp2; /* Search result */ |
144 | 170 |
145 if(filename == NULL) | 171 if(filename == NULL) |
146 { | 172 { |
147 DSOerr(DSO_F_VMS_LOAD,DSO_R_NO_FILENAME); | 173 DSOerr(DSO_F_VMS_LOAD,DSO_R_NO_FILENAME); |
148 goto err; | 174 goto err; |
149 } | 175 } |
150 | 176 |
151 /* A file specification may look like this: | 177 /* A file specification may look like this: |
152 * | 178 * |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
185 if (sp2 == NULL) sp2 = sp1 + strlen(sp1); | 211 if (sp2 == NULL) sp2 = sp1 + strlen(sp1); |
186 | 212 |
187 /* Check that we won't get buffer overflows */ | 213 /* Check that we won't get buffer overflows */ |
188 if (sp2 - sp1 > FILENAME_MAX | 214 if (sp2 - sp1 > FILENAME_MAX |
189 || (sp1 - filename) + strlen(sp2) > FILENAME_MAX) | 215 || (sp1 - filename) + strlen(sp2) > FILENAME_MAX) |
190 { | 216 { |
191 DSOerr(DSO_F_VMS_LOAD,DSO_R_FILENAME_TOO_BIG); | 217 DSOerr(DSO_F_VMS_LOAD,DSO_R_FILENAME_TOO_BIG); |
192 goto err; | 218 goto err; |
193 } | 219 } |
194 | 220 |
195 » p = (DSO_VMS_INTERNAL *)OPENSSL_malloc(sizeof(DSO_VMS_INTERNAL)); | 221 » p = DSO_MALLOC(sizeof(DSO_VMS_INTERNAL)); |
196 if(p == NULL) | 222 if(p == NULL) |
197 { | 223 { |
198 DSOerr(DSO_F_VMS_LOAD,ERR_R_MALLOC_FAILURE); | 224 DSOerr(DSO_F_VMS_LOAD,ERR_R_MALLOC_FAILURE); |
199 goto err; | 225 goto err; |
200 } | 226 } |
201 | 227 |
202 strncpy(p->filename, sp1, sp2-sp1); | 228 strncpy(p->filename, sp1, sp2-sp1); |
203 p->filename[sp2-sp1] = '\0'; | 229 p->filename[sp2-sp1] = '\0'; |
204 | 230 |
205 strncpy(p->imagename, filename, sp1-filename); | 231 strncpy(p->imagename, filename, sp1-filename); |
206 p->imagename[sp1-filename] = '\0'; | 232 p->imagename[sp1-filename] = '\0'; |
207 strcat(p->imagename, sp2); | 233 strcat(p->imagename, sp2); |
208 | 234 |
209 p->filename_dsc.dsc$w_length = strlen(p->filename); | 235 p->filename_dsc.dsc$w_length = strlen(p->filename); |
210 p->filename_dsc.dsc$b_dtype = DSC$K_DTYPE_T; | 236 p->filename_dsc.dsc$b_dtype = DSC$K_DTYPE_T; |
211 p->filename_dsc.dsc$b_class = DSC$K_CLASS_S; | 237 p->filename_dsc.dsc$b_class = DSC$K_CLASS_S; |
212 p->filename_dsc.dsc$a_pointer = p->filename; | 238 p->filename_dsc.dsc$a_pointer = p->filename; |
213 p->imagename_dsc.dsc$w_length = strlen(p->imagename); | 239 p->imagename_dsc.dsc$w_length = strlen(p->imagename); |
214 p->imagename_dsc.dsc$b_dtype = DSC$K_DTYPE_T; | 240 p->imagename_dsc.dsc$b_dtype = DSC$K_DTYPE_T; |
215 p->imagename_dsc.dsc$b_class = DSC$K_CLASS_S; | 241 p->imagename_dsc.dsc$b_class = DSC$K_CLASS_S; |
216 p->imagename_dsc.dsc$a_pointer = p->imagename; | 242 p->imagename_dsc.dsc$a_pointer = p->imagename; |
217 | 243 |
218 » if(!sk_push(dso->meth_data, (char *)p)) | 244 » if(!sk_void_push(dso->meth_data, (char *)p)) |
219 { | 245 { |
220 DSOerr(DSO_F_VMS_LOAD,DSO_R_STACK_ERROR); | 246 DSOerr(DSO_F_VMS_LOAD,DSO_R_STACK_ERROR); |
221 goto err; | 247 goto err; |
222 } | 248 } |
223 | 249 |
224 /* Success (for now, we lie. We actually do not know...) */ | 250 /* Success (for now, we lie. We actually do not know...) */ |
225 dso->loaded_filename = filename; | 251 dso->loaded_filename = filename; |
226 return(1); | 252 return(1); |
227 err: | 253 err: |
228 /* Cleanup! */ | 254 /* Cleanup! */ |
229 if(p != NULL) | 255 if(p != NULL) |
230 OPENSSL_free(p); | 256 OPENSSL_free(p); |
231 if(filename != NULL) | 257 if(filename != NULL) |
232 OPENSSL_free(filename); | 258 OPENSSL_free(filename); |
233 return(0); | 259 return(0); |
234 } | 260 } |
235 | 261 |
236 /* Note that this doesn't actually unload the shared image, as there is no | 262 /* Note that this doesn't actually unload the shared image, as there is no |
237 * such thing in VMS. Next time it get loaded again, a new copy will | 263 * such thing in VMS. Next time it get loaded again, a new copy will |
238 * actually be loaded. | 264 * actually be loaded. |
239 */ | 265 */ |
240 static int vms_unload(DSO *dso) | 266 static int vms_unload(DSO *dso) |
241 { | 267 { |
242 DSO_VMS_INTERNAL *p; | 268 DSO_VMS_INTERNAL *p; |
243 if(dso == NULL) | 269 if(dso == NULL) |
244 { | 270 { |
245 DSOerr(DSO_F_VMS_UNLOAD,ERR_R_PASSED_NULL_PARAMETER); | 271 DSOerr(DSO_F_VMS_UNLOAD,ERR_R_PASSED_NULL_PARAMETER); |
246 return(0); | 272 return(0); |
247 } | 273 } |
248 » if(sk_num(dso->meth_data) < 1) | 274 » if(sk_void_num(dso->meth_data) < 1) |
249 return(1); | 275 return(1); |
250 » p = (DSO_VMS_INTERNAL *)sk_pop(dso->meth_data); | 276 » p = (DSO_VMS_INTERNAL *)sk_void_pop(dso->meth_data); |
251 if(p == NULL) | 277 if(p == NULL) |
252 { | 278 { |
253 DSOerr(DSO_F_VMS_UNLOAD,DSO_R_NULL_HANDLE); | 279 DSOerr(DSO_F_VMS_UNLOAD,DSO_R_NULL_HANDLE); |
254 return(0); | 280 return(0); |
255 } | 281 } |
256 /* Cleanup */ | 282 /* Cleanup */ |
257 OPENSSL_free(p); | 283 OPENSSL_free(p); |
258 return(1); | 284 return(1); |
259 } | 285 } |
260 | 286 |
(...skipping 22 matching lines...) Expand all Loading... |
283 { | 309 { |
284 DSO_VMS_INTERNAL *ptr; | 310 DSO_VMS_INTERNAL *ptr; |
285 int status; | 311 int status; |
286 #if 0 | 312 #if 0 |
287 int flags = (1<<4); /* LIB$M_FIS_MIXEDCASE, but this symbol isn't | 313 int flags = (1<<4); /* LIB$M_FIS_MIXEDCASE, but this symbol isn't |
288 defined in VMS older than 7.0 or so */ | 314 defined in VMS older than 7.0 or so */ |
289 #else | 315 #else |
290 int flags = 0; | 316 int flags = 0; |
291 #endif | 317 #endif |
292 struct dsc$descriptor_s symname_dsc; | 318 struct dsc$descriptor_s symname_dsc; |
| 319 |
| 320 /* Arrange 32-bit pointer to (copied) string storage, if needed. */ |
| 321 #if __INITIAL_POINTER_SIZE == 64 |
| 322 # define SYMNAME symname_32p |
| 323 # pragma pointer_size save |
| 324 # pragma pointer_size 32 |
| 325 char *symname_32p; |
| 326 # pragma pointer_size restore |
| 327 char symname_32[ NAMX_MAXRSS+ 1]; |
| 328 #else /* __INITIAL_POINTER_SIZE == 64 */ |
| 329 # define SYMNAME ((char *) symname) |
| 330 #endif /* __INITIAL_POINTER_SIZE == 64 [else] */ |
| 331 |
293 *sym = NULL; | 332 *sym = NULL; |
294 | 333 |
295 symname_dsc.dsc$w_length = strlen(symname); | |
296 symname_dsc.dsc$b_dtype = DSC$K_DTYPE_T; | |
297 symname_dsc.dsc$b_class = DSC$K_CLASS_S; | |
298 symname_dsc.dsc$a_pointer = (char *)symname; /* The cast is needed */ | |
299 | |
300 if((dso == NULL) || (symname == NULL)) | 334 if((dso == NULL) || (symname == NULL)) |
301 { | 335 { |
302 DSOerr(DSO_F_VMS_BIND_SYM,ERR_R_PASSED_NULL_PARAMETER); | 336 DSOerr(DSO_F_VMS_BIND_SYM,ERR_R_PASSED_NULL_PARAMETER); |
303 return; | 337 return; |
304 } | 338 } |
305 » if(sk_num(dso->meth_data) < 1) | 339 |
| 340 #if __INITIAL_POINTER_SIZE == 64 |
| 341 » /* Copy the symbol name to storage with a 32-bit pointer. */ |
| 342 » symname_32p = symname_32; |
| 343 » strcpy( symname_32p, symname); |
| 344 #endif /* __INITIAL_POINTER_SIZE == 64 [else] */ |
| 345 |
| 346 » symname_dsc.dsc$w_length = strlen(SYMNAME); |
| 347 » symname_dsc.dsc$b_dtype = DSC$K_DTYPE_T; |
| 348 » symname_dsc.dsc$b_class = DSC$K_CLASS_S; |
| 349 » symname_dsc.dsc$a_pointer = SYMNAME; |
| 350 |
| 351 » if(sk_void_num(dso->meth_data) < 1) |
306 { | 352 { |
307 DSOerr(DSO_F_VMS_BIND_SYM,DSO_R_STACK_ERROR); | 353 DSOerr(DSO_F_VMS_BIND_SYM,DSO_R_STACK_ERROR); |
308 return; | 354 return; |
309 } | 355 } |
310 » ptr = (DSO_VMS_INTERNAL *)sk_value(dso->meth_data, | 356 » ptr = (DSO_VMS_INTERNAL *)sk_void_value(dso->meth_data, |
311 » » sk_num(dso->meth_data) - 1); | 357 » » sk_void_num(dso->meth_data) - 1); |
312 if(ptr == NULL) | 358 if(ptr == NULL) |
313 { | 359 { |
314 DSOerr(DSO_F_VMS_BIND_SYM,DSO_R_NULL_HANDLE); | 360 DSOerr(DSO_F_VMS_BIND_SYM,DSO_R_NULL_HANDLE); |
315 return; | 361 return; |
316 } | 362 } |
317 | 363 |
318 if(dso->flags & DSO_FLAG_UPCASE_SYMBOL) flags = 0; | 364 if(dso->flags & DSO_FLAG_UPCASE_SYMBOL) flags = 0; |
319 | 365 |
320 status = do_find_symbol(ptr, &symname_dsc, sym, flags); | 366 status = do_find_symbol(ptr, &symname_dsc, sym, flags); |
321 | 367 |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
365 return sym; | 411 return sym; |
366 } | 412 } |
367 | 413 |
368 static DSO_FUNC_TYPE vms_bind_func(DSO *dso, const char *symname) | 414 static DSO_FUNC_TYPE vms_bind_func(DSO *dso, const char *symname) |
369 { | 415 { |
370 DSO_FUNC_TYPE sym = 0; | 416 DSO_FUNC_TYPE sym = 0; |
371 vms_bind_sym(dso, symname, (void **)&sym); | 417 vms_bind_sym(dso, symname, (void **)&sym); |
372 return sym; | 418 return sym; |
373 } | 419 } |
374 | 420 |
| 421 |
375 static char *vms_merger(DSO *dso, const char *filespec1, const char *filespec2) | 422 static char *vms_merger(DSO *dso, const char *filespec1, const char *filespec2) |
376 { | 423 { |
377 int status; | 424 int status; |
378 int filespec1len, filespec2len; | 425 int filespec1len, filespec2len; |
379 struct FAB fab; | 426 struct FAB fab; |
380 #ifdef NAML$C_MAXRSS | 427 » struct NAMX_STRUCT nam; |
381 » struct NAML nam; | 428 » char esa[ NAMX_MAXRSS+ 1]; |
382 » char esa[NAML$C_MAXRSS]; | |
383 #else | |
384 » struct NAM nam; | |
385 » char esa[NAM$C_MAXRSS]; | |
386 #endif | |
387 char *merged; | 429 char *merged; |
388 | 430 |
| 431 /* Arrange 32-bit pointer to (copied) string storage, if needed. */ |
| 432 #if __INITIAL_POINTER_SIZE == 64 |
| 433 # define FILESPEC1 filespec1_32p; |
| 434 # define FILESPEC2 filespec2_32p; |
| 435 # pragma pointer_size save |
| 436 # pragma pointer_size 32 |
| 437 char *filespec1_32p; |
| 438 char *filespec2_32p; |
| 439 # pragma pointer_size restore |
| 440 char filespec1_32[ NAMX_MAXRSS+ 1]; |
| 441 char filespec2_32[ NAMX_MAXRSS+ 1]; |
| 442 #else /* __INITIAL_POINTER_SIZE == 64 */ |
| 443 # define FILESPEC1 ((char *) filespec1) |
| 444 # define FILESPEC2 ((char *) filespec2) |
| 445 #endif /* __INITIAL_POINTER_SIZE == 64 [else] */ |
| 446 |
389 if (!filespec1) filespec1 = ""; | 447 if (!filespec1) filespec1 = ""; |
390 if (!filespec2) filespec2 = ""; | 448 if (!filespec2) filespec2 = ""; |
391 filespec1len = strlen(filespec1); | 449 filespec1len = strlen(filespec1); |
392 filespec2len = strlen(filespec2); | 450 filespec2len = strlen(filespec2); |
393 | 451 |
| 452 #if __INITIAL_POINTER_SIZE == 64 |
| 453 /* Copy the file names to storage with a 32-bit pointer. */ |
| 454 filespec1_32p = filespec1_32; |
| 455 filespec2_32p = filespec2_32; |
| 456 strcpy( filespec1_32p, filespec1); |
| 457 strcpy( filespec2_32p, filespec2); |
| 458 #endif /* __INITIAL_POINTER_SIZE == 64 [else] */ |
| 459 |
394 fab = cc$rms_fab; | 460 fab = cc$rms_fab; |
395 #ifdef NAML$C_MAXRSS | 461 » nam = CC_RMS_NAMX; |
396 » nam = cc$rms_naml; | |
397 #else | |
398 » nam = cc$rms_nam; | |
399 #endif | |
400 | 462 |
401 » fab.fab$l_fna = (char *)filespec1; | 463 » FAB_OR_NAML( fab, nam).FAB_OR_NAML_FNA = FILESPEC1; |
402 » fab.fab$b_fns = filespec1len; | 464 » FAB_OR_NAML( fab, nam).FAB_OR_NAML_FNS = filespec1len; |
403 » fab.fab$l_dna = (char *)filespec2; | 465 » FAB_OR_NAML( fab, nam).FAB_OR_NAML_DNA = FILESPEC2; |
404 » fab.fab$b_dns = filespec2len; | 466 » FAB_OR_NAML( fab, nam).FAB_OR_NAML_DNS = filespec2len; |
405 #ifdef NAML$C_MAXRSS | 467 » NAMX_DNA_FNA_SET( fab) |
406 » if (filespec1len > NAM$C_MAXRSS) | 468 |
407 » » { | 469 » nam.NAMX_ESA = esa; |
408 » » fab.fab$l_fna = 0; | 470 » nam.NAMX_ESS = NAMX_MAXRSS; |
409 » » fab.fab$b_fns = 0; | 471 » nam.NAMX_NOP = NAM$M_SYNCHK | NAM$M_PWD; |
410 » » nam.naml$l_long_filename = (char *)filespec1; | 472 » SET_NAMX_NO_SHORT_UPCASE( nam); |
411 » » nam.naml$l_long_filename_size = filespec1len; | 473 |
412 » » } | 474 » fab.FAB_NAMX = &nam; |
413 » if (filespec2len > NAM$C_MAXRSS) | |
414 » » { | |
415 » » fab.fab$l_dna = 0; | |
416 » » fab.fab$b_dns = 0; | |
417 » » nam.naml$l_long_defname = (char *)filespec2; | |
418 » » nam.naml$l_long_defname_size = filespec2len; | |
419 » » } | |
420 » nam.naml$l_esa = esa; | |
421 » nam.naml$b_ess = NAM$C_MAXRSS; | |
422 » nam.naml$l_long_expand = esa; | |
423 » nam.naml$l_long_expand_alloc = sizeof(esa); | |
424 » nam.naml$b_nop = NAM$M_SYNCHK | NAM$M_PWD; | |
425 » nam.naml$v_no_short_upcase = 1; | |
426 » fab.fab$l_naml = &nam; | |
427 #else | |
428 » nam.nam$l_esa = esa; | |
429 » nam.nam$b_ess = NAM$C_MAXRSS; | |
430 » nam.nam$b_nop = NAM$M_SYNCHK | NAM$M_PWD; | |
431 » fab.fab$l_nam = &nam; | |
432 #endif | |
433 | 475 |
434 status = sys$parse(&fab, 0, 0); | 476 status = sys$parse(&fab, 0, 0); |
435 | 477 |
436 if(!$VMS_STATUS_SUCCESS(status)) | 478 if(!$VMS_STATUS_SUCCESS(status)) |
437 { | 479 { |
438 unsigned short length; | 480 unsigned short length; |
439 char errstring[257]; | 481 char errstring[257]; |
440 struct dsc$descriptor_s errstring_dsc; | 482 struct dsc$descriptor_s errstring_dsc; |
441 | 483 |
442 errstring_dsc.dsc$w_length = sizeof(errstring); | 484 errstring_dsc.dsc$w_length = sizeof(errstring); |
(...skipping 10 matching lines...) Expand all Loading... |
453 errstring[length] = '\0'; | 495 errstring[length] = '\0'; |
454 | 496 |
455 DSOerr(DSO_F_VMS_MERGER,DSO_R_FAILURE); | 497 DSOerr(DSO_F_VMS_MERGER,DSO_R_FAILURE); |
456 ERR_add_error_data(7, | 498 ERR_add_error_data(7, |
457 "filespec \"", filespec1, "\", ", | 499 "filespec \"", filespec1, "\", ", |
458 "defaults \"", filespec2, "\": ", | 500 "defaults \"", filespec2, "\": ", |
459 errstring); | 501 errstring); |
460 } | 502 } |
461 return(NULL); | 503 return(NULL); |
462 } | 504 } |
463 #ifdef NAML$C_MAXRSS | 505 |
464 » if (nam.naml$l_long_expand_size) | 506 » merged = OPENSSL_malloc( nam.NAMX_ESL+ 1); |
465 » » { | |
466 » » merged = OPENSSL_malloc(nam.naml$l_long_expand_size + 1); | |
467 » » if(!merged) | |
468 » » » goto malloc_err; | |
469 » » strncpy(merged, nam.naml$l_long_expand, | |
470 » » » nam.naml$l_long_expand_size); | |
471 » » merged[nam.naml$l_long_expand_size] = '\0'; | |
472 » » } | |
473 » else | |
474 » » { | |
475 » » merged = OPENSSL_malloc(nam.naml$b_esl + 1); | |
476 » » if(!merged) | |
477 » » » goto malloc_err; | |
478 » » strncpy(merged, nam.naml$l_esa, | |
479 » » » nam.naml$b_esl); | |
480 » » merged[nam.naml$b_esl] = '\0'; | |
481 » » } | |
482 #else | |
483 » merged = OPENSSL_malloc(nam.nam$b_esl + 1); | |
484 if(!merged) | 507 if(!merged) |
485 goto malloc_err; | 508 goto malloc_err; |
486 » strncpy(merged, nam.nam$l_esa, | 509 » strncpy( merged, nam.NAMX_ESA, nam.NAMX_ESL); |
487 » » nam.nam$b_esl); | 510 » merged[ nam.NAMX_ESL] = '\0'; |
488 » merged[nam.nam$b_esl] = '\0'; | |
489 #endif | |
490 return(merged); | 511 return(merged); |
491 malloc_err: | 512 malloc_err: |
492 DSOerr(DSO_F_VMS_MERGER, | 513 DSOerr(DSO_F_VMS_MERGER, |
493 ERR_R_MALLOC_FAILURE); | 514 ERR_R_MALLOC_FAILURE); |
494 } | 515 } |
495 | 516 |
496 static char *vms_name_converter(DSO *dso, const char *filename) | 517 static char *vms_name_converter(DSO *dso, const char *filename) |
497 { | 518 { |
498 int len = strlen(filename); | 519 int len = strlen(filename); |
499 char *not_translated = OPENSSL_malloc(len+1); | 520 char *not_translated = OPENSSL_malloc(len+1); |
500 strcpy(not_translated,filename); | 521 strcpy(not_translated,filename); |
501 return(not_translated); | 522 return(not_translated); |
502 } | 523 } |
503 | 524 |
504 #endif /* OPENSSL_SYS_VMS */ | 525 #endif /* OPENSSL_SYS_VMS */ |
OLD | NEW |