← Back to branch summary

~andersk/ubuntu/oneiric/openssl/spurious-reboot

« back to all changes in this revision

Viewing changes to crypto/dso/dso_vms.c

  • Committer: Package Import Robot
  • Author(s): Steve Beattie
  • Date: 2011-09-14 22:06:03 UTC
  • mfrom: (11.1.23 sid)
  • Revision ID: package-import@ubuntu.com-20110914220603-tsuxw8z3kt4lx9oc
Tags: 1.0.0e-2ubuntu1
https://launchpad.net/bugs/850608
https://launchpad.net/bugs/244250
* Resynchronise with Debian, fixes CVE-2011-1945, CVE-2011-3207 and
  CVE-2011-3210 (LP: #850608). Remaining changes:
  - debian/libssl1.0.0.postinst:
    + Display a system restart required notification bubble on libssl1.0.0
      upgrade.
    + Use a different priority for libssl1.0.0/restart-services depending
      on whether a desktop, or server dist-upgrade is being performed.
  - debian/{libssl1.0.0-udeb.dirs, control, rules}: Create
    libssl1.0.0-udeb, for the benefit of wget-udeb (no wget-udeb package
    in Debian).
  - debian/{libcrypto1.0.0-udeb.dirs, libssl1.0.0.dirs, libssl1.0.0.files,
    rules}: Move runtime libraries to /lib, for the benefit of
    wpasupplicant.
  - debian/patches/aesni.patch: Backport Intel AES-NI support, now from
    http://rt.openssl.org/Ticket/Display.html?id=2065 rather than the
    0.9.8 variant.
  - debian/patches/Bsymbolic-functions.patch: Link using
    -Bsymbolic-functions.
  - debian/patches/perlpath-quilt.patch: Don't change perl #! paths under
    .pc.
  - debian/rules:
    + Don't run 'make test' when cross-building.
    + Use host compiler when cross-building.  Patch from Neil Williams.
    + Don't build for processors no longer supported: i486, i586 (on
      i386), v8 (on sparc).
    + Fix Makefile to properly clean up libs/ dirs in clean target.
    + Replace duplicate files in the doc directory with symlinks.
* debian/libssl1.0.0.postinst: only display restart notification on
  servers (LP: #244250)

Show diffs side-by-side

added added

removed removed

Lines of Context:
crypto/dso/dso_vms.c
68
68
#include <stsdef.h>
69
69
#include <descrip.h>
70
70
#include <starlet.h>
 
71
#include "vms_rms.h"
71
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
85
#ifndef OPENSSL_SYS_VMS
74
86
DSO_METHOD *DSO_METHOD_vms(void)
75
87
        {
121
133
        /* This should contain the name only, no directory,
122
134
         * no extension, nothing but a name. */
123
135
        struct dsc$descriptor_s filename_dsc;
124
 
        char filename[FILENAME_MAX+1];
 
136
        char filename[ NAMX_MAXRSS+ 1];
125
137
        /* This contains whatever is not in filename, if needed.
126
138
         * Normally not defined. */
127
139
        struct dsc$descriptor_s imagename_dsc;
128
 
        char imagename[FILENAME_MAX+1];
 
140
        char imagename[ NAMX_MAXRSS+ 1];
129
141
        } DSO_VMS_INTERNAL;
130
142
 
131
 
 
132
143
DSO_METHOD *DSO_METHOD_vms(void)
133
144
        {
134
145
        return(&dso_meth_vms);
139
150
        void *ptr = NULL;
140
151
        /* See applicable comments in dso_dl.c */
141
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
169
        const char *sp1, *sp2;  /* Search result */
144
170
 
145
171
        if(filename == NULL)
192
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
222
        if(p == NULL)
197
223
                {
198
224
                DSOerr(DSO_F_VMS_LOAD,ERR_R_MALLOC_FAILURE);
290
316
        int flags = 0;
291
317
#endif
292
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
332
        *sym = NULL;
294
333
 
295
 
        symname_dsc.dsc$w_length = strlen(symname);
 
334
        if((dso == NULL) || (symname == NULL))
 
335
                {
 
336
                DSOerr(DSO_F_VMS_BIND_SYM,ERR_R_PASSED_NULL_PARAMETER);
 
337
                return;
 
338
                }
 
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);
296
347
        symname_dsc.dsc$b_dtype = DSC$K_DTYPE_T;
297
348
        symname_dsc.dsc$b_class = DSC$K_CLASS_S;
298
 
        symname_dsc.dsc$a_pointer = (char *)symname; /* The cast is needed */
 
349
        symname_dsc.dsc$a_pointer = SYMNAME;
299
350
 
300
 
        if((dso == NULL) || (symname == NULL))
301
 
                {
302
 
                DSOerr(DSO_F_VMS_BIND_SYM,ERR_R_PASSED_NULL_PARAMETER);
303
 
                return;
304
 
                }
305
351
        if(sk_void_num(dso->meth_data) < 1)
306
352
                {
307
353
                DSOerr(DSO_F_VMS_BIND_SYM,DSO_R_STACK_ERROR);
372
418
        return sym;
373
419
        }
374
420
 
 
421
 
375
422
static char *vms_merger(DSO *dso, const char *filespec1, const char *filespec2)
376
423
        {
377
424
        int status;
378
425
        int filespec1len, filespec2len;
379
426
        struct FAB fab;
380
 
#ifdef NAML$C_MAXRSS
381
 
        struct NAML nam;
382
 
        char esa[NAML$C_MAXRSS];
383
 
#else
384
 
        struct NAM nam;
385
 
        char esa[NAM$C_MAXRSS];
386
 
#endif
 
427
        struct NAMX_STRUCT nam;
 
428
        char esa[ NAMX_MAXRSS+ 1];
387
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
447
        if (!filespec1) filespec1 = "";
390
448
        if (!filespec2) filespec2 = "";
391
449
        filespec1len = strlen(filespec1);
392
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
460
        fab = cc$rms_fab;
395
 
#ifdef NAML$C_MAXRSS
396
 
        nam = cc$rms_naml;
397
 
#else
398
 
        nam = cc$rms_nam;
399
 
#endif
400
 
 
401
 
        fab.fab$l_fna = (char *)filespec1;
402
 
        fab.fab$b_fns = filespec1len;
403
 
        fab.fab$l_dna = (char *)filespec2;
404
 
        fab.fab$b_dns = filespec2len;
405
 
#ifdef NAML$C_MAXRSS
406
 
        if (filespec1len > NAM$C_MAXRSS)
407
 
                {
408
 
                fab.fab$l_fna = 0;
409
 
                fab.fab$b_fns = 0;
410
 
                nam.naml$l_long_filename = (char *)filespec1;
411
 
                nam.naml$l_long_filename_size = filespec1len;
412
 
                }
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
 
461
        nam = CC_RMS_NAMX;
 
462
 
 
463
        FAB_OR_NAML( fab, nam).FAB_OR_NAML_FNA = FILESPEC1;
 
464
        FAB_OR_NAML( fab, nam).FAB_OR_NAML_FNS = filespec1len;
 
465
        FAB_OR_NAML( fab, nam).FAB_OR_NAML_DNA = FILESPEC2;
 
466
        FAB_OR_NAML( fab, nam).FAB_OR_NAML_DNS = filespec2len;
 
467
        NAMX_DNA_FNA_SET( fab)
 
468
 
 
469
        nam.NAMX_ESA = esa;
 
470
        nam.NAMX_ESS = NAMX_MAXRSS;
 
471
        nam.NAMX_NOP = NAM$M_SYNCHK | NAM$M_PWD;
 
472
        SET_NAMX_NO_SHORT_UPCASE( nam);
 
473
 
 
474
        fab.FAB_NAMX = &nam;
433
475
 
434
476
        status = sys$parse(&fab, 0, 0);
435
477
 
460
502
                        }
461
503
                return(NULL);
462
504
                }
463
 
#ifdef NAML$C_MAXRSS
464
 
        if (nam.naml$l_long_expand_size)
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);
 
505
 
 
506
        merged = OPENSSL_malloc( nam.NAMX_ESL+ 1);
484
507
        if(!merged)
485
508
                goto malloc_err;
486
 
        strncpy(merged, nam.nam$l_esa,
487
 
                nam.nam$b_esl);
488
 
        merged[nam.nam$b_esl] = '\0';
489
 
#endif
 
509
        strncpy( merged, nam.NAMX_ESA, nam.NAMX_ESL);
 
510
        merged[ nam.NAMX_ESL] = '\0';
490
511
        return(merged);
491
512
 malloc_err:
492
513
        DSOerr(DSO_F_VMS_MERGER,