Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(125)

Side by Side Diff: nss/lib/nss/utilwrap.c

Issue 2078763002: Delete bundled copy of NSS and replace with README. (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/nss@master
Patch Set: Delete bundled copy of NSS and replace with README. Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « nss/lib/nss/nssver.c ('k') | nss/lib/pk11wrap/debug_module.c » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 /*
2 * NSS utility functions
3 *
4 * This Source Code Form is subject to the terms of the Mozilla Public
5 * License, v. 2.0. If a copy of the MPL was not distributed with this
6 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7
8 #include "secport.h"
9 #include "secoid.h"
10 #include "secitem.h"
11 #include "secdig.h"
12 #include "secder.h"
13 #include "secasn1.h"
14 #include "base64.h"
15 #include "nssb64.h"
16 #include "nssrwlk.h"
17 #include "cert.h"
18 #include "prerror.h"
19
20 /* wrappers for implementation in libnssutil3 */
21 #undef ATOB_AsciiToData
22 #undef ATOB_ConvertAsciiToItem
23 #undef BTOA_ConvertItemToAscii
24 #undef BTOA_DataToAscii
25 #undef CERT_GenTime2FormattedAscii
26 #undef DER_AsciiToTime
27 #undef DER_DecodeTimeChoice
28 #undef DER_Encode
29 #undef DER_EncodeTimeChoice
30 #undef DER_GeneralizedDayToAscii
31 #undef DER_GeneralizedTimeToTime
32 #undef DER_GetInteger
33 #undef DER_Lengths
34 #undef DER_TimeChoiceDayToAscii
35 #undef DER_TimeToGeneralizedTime
36 #undef DER_TimeToGeneralizedTimeArena
37 #undef DER_TimeToUTCTime
38 #undef DER_UTCDayToAscii
39 #undef DER_UTCTimeToAscii
40 #undef DER_UTCTimeToTime
41 #undef NSS_PutEnv
42 #undef NSSBase64_DecodeBuffer
43 #undef NSSBase64_EncodeItem
44 #undef NSSBase64Decoder_Create
45 #undef NSSBase64Decoder_Destroy
46 #undef NSSBase64Decoder_Update
47 #undef NSSBase64Encoder_Create
48 #undef NSSBase64Encoder_Destroy
49 #undef NSSBase64Encoder_Update
50 #undef NSSRWLock_Destroy
51 #undef NSSRWLock_HaveWriteLock
52 #undef NSSRWLock_LockRead
53 #undef NSSRWLock_LockWrite
54 #undef NSSRWLock_New
55 #undef NSSRWLock_UnlockRead
56 #undef NSSRWLock_UnlockWrite
57 #undef PORT_Alloc
58 #undef PORT_ArenaAlloc
59 #undef PORT_ArenaGrow
60 #undef PORT_ArenaMark
61 #undef PORT_ArenaRelease
62 #undef PORT_ArenaStrdup
63 #undef PORT_ArenaUnmark
64 #undef PORT_ArenaZAlloc
65 #undef PORT_Free
66 #undef PORT_FreeArena
67 #undef PORT_GetError
68 #undef PORT_NewArena
69 #undef PORT_Realloc
70 #undef PORT_SetError
71 #undef PORT_SetUCS2_ASCIIConversionFunction
72 #undef PORT_SetUCS2_UTF8ConversionFunction
73 #undef PORT_SetUCS4_UTF8ConversionFunction
74 #undef PORT_Strdup
75 #undef PORT_UCS2_ASCIIConversion
76 #undef PORT_UCS2_UTF8Conversion
77 #undef PORT_ZAlloc
78 #undef PORT_ZFree
79 #undef SEC_ASN1Decode
80 #undef SEC_ASN1DecodeInteger
81 #undef SEC_ASN1DecodeItem
82 #undef SEC_ASN1DecoderAbort
83 #undef SEC_ASN1DecoderClearFilterProc
84 #undef SEC_ASN1DecoderClearNotifyProc
85 #undef SEC_ASN1DecoderFinish
86 #undef SEC_ASN1DecoderSetFilterProc
87 #undef SEC_ASN1DecoderSetNotifyProc
88 #undef SEC_ASN1DecoderStart
89 #undef SEC_ASN1DecoderUpdate
90 #undef SEC_ASN1Encode
91 #undef SEC_ASN1EncodeInteger
92 #undef SEC_ASN1EncodeItem
93 #undef SEC_ASN1EncoderAbort
94 #undef SEC_ASN1EncoderClearNotifyProc
95 #undef SEC_ASN1EncoderClearStreaming
96 #undef SEC_ASN1EncoderClearTakeFromBuf
97 #undef SEC_ASN1EncoderFinish
98 #undef SEC_ASN1EncoderSetNotifyProc
99 #undef SEC_ASN1EncoderSetStreaming
100 #undef SEC_ASN1EncoderSetTakeFromBuf
101 #undef SEC_ASN1EncoderStart
102 #undef SEC_ASN1EncoderUpdate
103 #undef SEC_ASN1EncodeUnsignedInteger
104 #undef SEC_ASN1LengthLength
105 #undef SEC_QuickDERDecodeItem
106 #undef SECITEM_AllocItem
107 #undef SECITEM_ArenaDupItem
108 #undef SECITEM_CompareItem
109 #undef SECITEM_CopyItem
110 #undef SECITEM_DupItem
111 #undef SECITEM_FreeItem
112 #undef SECITEM_ItemsAreEqual
113 #undef SECITEM_ZfreeItem
114 #undef SECOID_AddEntry
115 #undef SECOID_CompareAlgorithmID
116 #undef SECOID_CopyAlgorithmID
117 #undef SECOID_DestroyAlgorithmID
118 #undef SECOID_FindOID
119 #undef SECOID_FindOIDByTag
120 #undef SECOID_FindOIDTag
121 #undef SECOID_FindOIDTagDescription
122 #undef SECOID_GetAlgorithmTag
123 #undef SECOID_SetAlgorithmID
124 #undef SGN_CompareDigestInfo
125 #undef SGN_CopyDigestInfo
126 #undef SGN_CreateDigestInfo
127 #undef SGN_DestroyDigestInfo
128
129 void *
130 PORT_Alloc(size_t bytes)
131 {
132 return PORT_Alloc_Util(bytes);
133 }
134
135 void *
136 PORT_Realloc(void *oldptr, size_t bytes)
137 {
138 return PORT_Realloc_Util(oldptr, bytes);
139 }
140
141 void *
142 PORT_ZAlloc(size_t bytes)
143 {
144 return PORT_ZAlloc_Util(bytes);
145 }
146
147 void
148 PORT_Free(void *ptr)
149 {
150 PORT_Free_Util(ptr);
151 }
152
153 void
154 PORT_ZFree(void *ptr, size_t len)
155 {
156 PORT_ZFree_Util(ptr, len);
157 }
158
159 char *
160 PORT_Strdup(const char *str)
161 {
162 return PORT_Strdup_Util(str);
163 }
164
165 void
166 PORT_SetError(int value)
167 {
168 PORT_SetError_Util(value);
169 }
170
171 int
172 PORT_GetError(void)
173 {
174 return PORT_GetError_Util();
175 }
176
177 PLArenaPool *
178 PORT_NewArena(unsigned long chunksize)
179 {
180 return PORT_NewArena_Util(chunksize);
181 }
182
183 void *
184 PORT_ArenaAlloc(PLArenaPool *arena, size_t size)
185 {
186 return PORT_ArenaAlloc_Util(arena, size);
187 }
188
189 void *
190 PORT_ArenaZAlloc(PLArenaPool *arena, size_t size)
191 {
192 return PORT_ArenaZAlloc_Util(arena, size);
193 }
194
195 void
196 PORT_FreeArena(PLArenaPool *arena, PRBool zero)
197 {
198 PORT_FreeArena_Util(arena, zero);
199 }
200
201 void *
202 PORT_ArenaGrow(PLArenaPool *arena, void *ptr, size_t oldsize, size_t newsize)
203 {
204 return PORT_ArenaGrow_Util(arena, ptr, oldsize, newsize);
205 }
206
207 void *
208 PORT_ArenaMark(PLArenaPool *arena)
209 {
210 return PORT_ArenaMark_Util(arena);
211 }
212
213 void
214 PORT_ArenaRelease(PLArenaPool *arena, void *mark)
215 {
216 PORT_ArenaRelease_Util(arena, mark);
217 }
218
219 void
220 PORT_ArenaUnmark(PLArenaPool *arena, void *mark)
221 {
222 PORT_ArenaUnmark_Util(arena, mark);
223 }
224
225 char *
226 PORT_ArenaStrdup(PLArenaPool *arena, const char *str)
227 {
228 return PORT_ArenaStrdup_Util(arena, str);
229 }
230
231 void
232 PORT_SetUCS4_UTF8ConversionFunction(PORTCharConversionFunc convFunc)
233 {
234 PORT_SetUCS4_UTF8ConversionFunction_Util(convFunc);
235 }
236
237 void
238 PORT_SetUCS2_ASCIIConversionFunction(PORTCharConversionWSwapFunc convFunc)
239 {
240 PORT_SetUCS2_ASCIIConversionFunction_Util(convFunc);
241 }
242
243 void
244 PORT_SetUCS2_UTF8ConversionFunction(PORTCharConversionFunc convFunc)
245 {
246 PORT_SetUCS2_UTF8ConversionFunction_Util(convFunc);
247 }
248
249 PRBool
250 PORT_UCS2_UTF8Conversion(PRBool toUnicode, unsigned char *inBuf,
251 unsigned int inBufLen, unsigned char *outBuf,
252 unsigned int maxOutBufLen, unsigned int *outBufLen)
253 {
254 return PORT_UCS2_UTF8Conversion_Util(toUnicode, inBuf, inBufLen, outBuf,
255 maxOutBufLen, outBufLen);
256 }
257
258 PRBool
259 PORT_UCS2_ASCIIConversion(PRBool toUnicode, unsigned char *inBuf,
260 unsigned int inBufLen, unsigned char *outBuf,
261 unsigned int maxOutBufLen, unsigned int *outBufLen,
262 PRBool swapBytes)
263 {
264 return PORT_UCS2_ASCIIConversion_Util(toUnicode, inBuf, inBufLen, outBuf,
265 maxOutBufLen, outBufLen, swapBytes);
266 }
267
268 int
269 NSS_PutEnv(const char * envVarName, const char * envValue)
270 {
271 return NSS_PutEnv_Util(envVarName, envValue);
272 }
273
274 SECOidData *SECOID_FindOID( const SECItem *oid)
275 {
276 return SECOID_FindOID_Util(oid);
277 }
278
279 SECOidTag SECOID_FindOIDTag(const SECItem *oid)
280 {
281 return SECOID_FindOIDTag_Util(oid);
282 }
283
284 SECOidData *SECOID_FindOIDByTag(SECOidTag tagnum)
285 {
286 return SECOID_FindOIDByTag_Util(tagnum);
287 }
288
289 SECStatus SECOID_SetAlgorithmID(PLArenaPool *arena, SECAlgorithmID *aid,
290 SECOidTag tag, SECItem *params)
291 {
292 return SECOID_SetAlgorithmID_Util(arena, aid, tag, params);
293 }
294
295 SECStatus SECOID_CopyAlgorithmID(PLArenaPool *arena, SECAlgorithmID *dest,
296 const SECAlgorithmID *src)
297 {
298 return SECOID_CopyAlgorithmID_Util(arena, dest, src);
299 }
300
301 SECOidTag SECOID_GetAlgorithmTag(const SECAlgorithmID *aid)
302 {
303 return SECOID_GetAlgorithmTag_Util(aid);
304 }
305
306 void SECOID_DestroyAlgorithmID(SECAlgorithmID *aid, PRBool freeit)
307 {
308 SECOID_DestroyAlgorithmID_Util(aid, freeit);
309 }
310
311 SECComparison SECOID_CompareAlgorithmID(SECAlgorithmID *a,
312 SECAlgorithmID *b)
313 {
314 return SECOID_CompareAlgorithmID_Util(a, b);
315 }
316
317 const char *SECOID_FindOIDTagDescription(SECOidTag tagnum)
318 {
319 return SECOID_FindOIDTagDescription_Util(tagnum);
320 }
321
322 SECOidTag SECOID_AddEntry(const SECOidData * src)
323 {
324 return SECOID_AddEntry_Util(src);
325 }
326
327 SECItem *SECITEM_AllocItem(PLArenaPool *arena, SECItem *item,
328 unsigned int len)
329 {
330 return SECITEM_AllocItem_Util(arena, item, len);
331 }
332
333 SECComparison SECITEM_CompareItem(const SECItem *a, const SECItem *b)
334 {
335 return SECITEM_CompareItem_Util(a, b);
336 }
337
338 PRBool SECITEM_ItemsAreEqual(const SECItem *a, const SECItem *b)
339 {
340 return SECITEM_ItemsAreEqual_Util(a, b);
341 }
342
343 SECStatus SECITEM_CopyItem(PLArenaPool *arena, SECItem *to,
344 const SECItem *from)
345 {
346 return SECITEM_CopyItem_Util(arena, to, from);
347 }
348
349 SECItem *SECITEM_DupItem(const SECItem *from)
350 {
351 return SECITEM_DupItem_Util(from);
352 }
353
354 SECItem *SECITEM_ArenaDupItem(PLArenaPool *arena, const SECItem *from)
355 {
356 return SECITEM_ArenaDupItem_Util(arena, from);
357 }
358
359 void SECITEM_FreeItem(SECItem *zap, PRBool freeit)
360 {
361 SECITEM_FreeItem_Util(zap, freeit);
362 }
363
364 void SECITEM_ZfreeItem(SECItem *zap, PRBool freeit)
365 {
366 SECITEM_ZfreeItem_Util(zap, freeit);
367 }
368
369 SGNDigestInfo *SGN_CreateDigestInfo(SECOidTag algorithm,
370 unsigned char *sig,
371 unsigned int sigLen)
372 {
373 return SGN_CreateDigestInfo_Util(algorithm, sig, sigLen);
374 }
375
376 void SGN_DestroyDigestInfo(SGNDigestInfo *info)
377 {
378 SGN_DestroyDigestInfo_Util(info);
379 }
380
381 SECStatus SGN_CopyDigestInfo(PLArenaPool *poolp,
382 SGNDigestInfo *a,
383 SGNDigestInfo *b)
384 {
385 return SGN_CopyDigestInfo_Util(poolp, a, b);
386 }
387
388 SECComparison SGN_CompareDigestInfo(SGNDigestInfo *a, SGNDigestInfo *b)
389 {
390 return SGN_CompareDigestInfo_Util(a, b);
391 }
392
393 SECStatus DER_Encode(PLArenaPool *arena, SECItem *dest, DERTemplate *t,
394 void *src)
395 {
396 return DER_Encode_Util(arena, dest, t, src);
397 }
398
399 SECStatus DER_Lengths(SECItem *item, int *header_len_p,
400 PRUint32 *contents_len_p)
401 {
402 return DER_Lengths_Util(item, header_len_p, contents_len_p);
403 }
404
405 long DER_GetInteger(const SECItem *src)
406 {
407 return DER_GetInteger_Util(src);
408 }
409
410 SECStatus DER_TimeToUTCTime(SECItem *result, PRTime time)
411 {
412 return DER_TimeToUTCTime_Util(result, time);
413 }
414
415 SECStatus DER_AsciiToTime(PRTime *result, const char *string)
416 {
417 return DER_AsciiToTime_Util(result, string);
418 }
419
420 SECStatus DER_UTCTimeToTime(PRTime *result, const SECItem *time)
421 {
422 return DER_UTCTimeToTime_Util(result, time);
423 }
424
425 char *DER_UTCTimeToAscii(SECItem *utcTime)
426 {
427 return DER_UTCTimeToAscii_Util(utcTime);
428 }
429
430 char *DER_UTCDayToAscii(SECItem *utctime)
431 {
432 return DER_UTCDayToAscii_Util(utctime);
433 }
434
435 char *DER_GeneralizedDayToAscii(SECItem *gentime)
436 {
437 return DER_GeneralizedDayToAscii_Util(gentime);
438 }
439
440 char *DER_TimeChoiceDayToAscii(SECItem *timechoice)
441 {
442 return DER_TimeChoiceDayToAscii_Util(timechoice);
443 }
444
445 SECStatus DER_TimeToGeneralizedTime(SECItem *dst, PRTime gmttime)
446 {
447 return DER_TimeToGeneralizedTime_Util(dst, gmttime);
448 }
449
450 SECStatus DER_TimeToGeneralizedTimeArena(PLArenaPool* arenaOpt,
451 SECItem *dst, PRTime gmttime)
452 {
453 return DER_TimeToGeneralizedTimeArena_Util(arenaOpt, dst, gmttime);
454 }
455
456 SECStatus DER_GeneralizedTimeToTime(PRTime *dst, const SECItem *time)
457 {
458 return DER_GeneralizedTimeToTime_Util(dst, time);
459 }
460
461 char *CERT_GenTime2FormattedAscii(PRTime genTime, char *format)
462 {
463 return CERT_GenTime2FormattedAscii_Util(genTime, format);
464 }
465
466 SECStatus DER_DecodeTimeChoice(PRTime* output, const SECItem* input)
467 {
468 return DER_DecodeTimeChoice_Util(output, input);
469 }
470
471 SECStatus DER_EncodeTimeChoice(PLArenaPool* arena, SECItem* output,
472 PRTime input)
473 {
474 return DER_EncodeTimeChoice_Util(arena, output, input);
475 }
476
477 SEC_ASN1DecoderContext *SEC_ASN1DecoderStart(PLArenaPool *pool,
478 void *dest,
479 const SEC_ASN1Template *t)
480 {
481 return SEC_ASN1DecoderStart_Util(pool, dest, t);
482 }
483
484 SECStatus SEC_ASN1DecoderUpdate(SEC_ASN1DecoderContext *cx,
485 const char *buf,
486 unsigned long len)
487 {
488 return SEC_ASN1DecoderUpdate_Util(cx, buf, len);
489 }
490
491 SECStatus SEC_ASN1DecoderFinish(SEC_ASN1DecoderContext *cx)
492 {
493 return SEC_ASN1DecoderFinish_Util(cx);
494 }
495
496 void SEC_ASN1DecoderAbort(SEC_ASN1DecoderContext *cx, int error)
497 {
498 SEC_ASN1DecoderAbort_Util(cx, error);
499 }
500
501 void SEC_ASN1DecoderSetFilterProc(SEC_ASN1DecoderContext *cx,
502 SEC_ASN1WriteProc fn,
503 void *arg, PRBool no_store)
504 {
505 SEC_ASN1DecoderSetFilterProc_Util(cx, fn, arg, no_store);
506 }
507
508 void SEC_ASN1DecoderClearFilterProc(SEC_ASN1DecoderContext *cx)
509 {
510 SEC_ASN1DecoderClearFilterProc_Util(cx);
511 }
512
513 void SEC_ASN1DecoderSetNotifyProc(SEC_ASN1DecoderContext *cx,
514 SEC_ASN1NotifyProc fn,
515 void *arg)
516 {
517 SEC_ASN1DecoderSetNotifyProc_Util(cx, fn, arg);
518 }
519
520 void SEC_ASN1DecoderClearNotifyProc(SEC_ASN1DecoderContext *cx)
521 {
522 SEC_ASN1DecoderClearNotifyProc_Util(cx);
523 }
524
525 SECStatus SEC_ASN1Decode(PLArenaPool *pool, void *dest,
526 const SEC_ASN1Template *t,
527 const char *buf, long len)
528 {
529 return SEC_ASN1Decode_Util(pool, dest, t, buf, len);
530 }
531
532 SECStatus SEC_ASN1DecodeItem(PLArenaPool *pool, void *dest,
533 const SEC_ASN1Template *t,
534 const SECItem *src)
535 {
536 return SEC_ASN1DecodeItem_Util(pool, dest, t, src);
537 }
538
539 SECStatus SEC_QuickDERDecodeItem(PLArenaPool* arena, void* dest,
540 const SEC_ASN1Template* templateEntry,
541 const SECItem* src)
542 {
543 return SEC_QuickDERDecodeItem_Util(arena, dest, templateEntry, src);
544 }
545
546 SEC_ASN1EncoderContext *SEC_ASN1EncoderStart(const void *src,
547 const SEC_ASN1Template *t,
548 SEC_ASN1WriteProc fn,
549 void *output_arg)
550 {
551 return SEC_ASN1EncoderStart_Util(src, t, fn, output_arg);
552 }
553
554 SECStatus SEC_ASN1EncoderUpdate(SEC_ASN1EncoderContext *cx,
555 const char *buf,
556 unsigned long len)
557 {
558 return SEC_ASN1EncoderUpdate_Util(cx, buf, len);
559 }
560
561 void SEC_ASN1EncoderFinish(SEC_ASN1EncoderContext *cx)
562 {
563 SEC_ASN1EncoderFinish_Util(cx);
564 }
565
566 void SEC_ASN1EncoderAbort(SEC_ASN1EncoderContext *cx, int error)
567 {
568 SEC_ASN1EncoderAbort_Util(cx, error);
569 }
570
571 void SEC_ASN1EncoderSetNotifyProc(SEC_ASN1EncoderContext *cx,
572 SEC_ASN1NotifyProc fn,
573 void *arg)
574 {
575 SEC_ASN1EncoderSetNotifyProc_Util(cx, fn, arg);
576 }
577
578 void SEC_ASN1EncoderClearNotifyProc(SEC_ASN1EncoderContext *cx)
579 {
580 SEC_ASN1EncoderClearNotifyProc_Util(cx);
581 }
582
583 void SEC_ASN1EncoderSetStreaming(SEC_ASN1EncoderContext *cx)
584 {
585 SEC_ASN1EncoderSetStreaming_Util(cx);
586 }
587
588 void SEC_ASN1EncoderClearStreaming(SEC_ASN1EncoderContext *cx)
589 {
590 SEC_ASN1EncoderClearStreaming_Util(cx);
591 }
592
593 void SEC_ASN1EncoderSetTakeFromBuf(SEC_ASN1EncoderContext *cx)
594 {
595 SEC_ASN1EncoderSetTakeFromBuf_Util(cx);
596 }
597
598 void SEC_ASN1EncoderClearTakeFromBuf(SEC_ASN1EncoderContext *cx)
599 {
600 SEC_ASN1EncoderClearTakeFromBuf_Util(cx);
601 }
602
603 SECStatus SEC_ASN1Encode(const void *src, const SEC_ASN1Template *t,
604 SEC_ASN1WriteProc output_proc,
605 void *output_arg)
606 {
607 return SEC_ASN1Encode_Util(src, t, output_proc, output_arg);
608 }
609
610 SECItem * SEC_ASN1EncodeItem(PLArenaPool *pool, SECItem *dest,
611 const void *src, const SEC_ASN1Template *t)
612 {
613 return SEC_ASN1EncodeItem_Util(pool, dest, src, t);
614 }
615
616 SECItem * SEC_ASN1EncodeInteger(PLArenaPool *pool,
617 SECItem *dest, long value)
618 {
619 return SEC_ASN1EncodeInteger_Util(pool, dest, value);
620 }
621
622 SECItem * SEC_ASN1EncodeUnsignedInteger(PLArenaPool *pool,
623 SECItem *dest,
624 unsigned long value)
625 {
626 return SEC_ASN1EncodeUnsignedInteger_Util(pool, dest, value);
627 }
628
629 SECStatus SEC_ASN1DecodeInteger(SECItem *src,
630 unsigned long *value)
631 {
632 return SEC_ASN1DecodeInteger_Util(src, value);
633 }
634
635 int SEC_ASN1LengthLength (unsigned long len)
636 {
637 return SEC_ASN1LengthLength_Util(len);
638 }
639
640 char *BTOA_DataToAscii(const unsigned char *data, unsigned int len)
641 {
642 return BTOA_DataToAscii_Util(data, len);
643 }
644
645 unsigned char *ATOB_AsciiToData(const char *string, unsigned int *lenp)
646 {
647 return ATOB_AsciiToData_Util(string, lenp);
648 }
649
650 SECStatus ATOB_ConvertAsciiToItem(SECItem *binary_item, const char *ascii)
651 {
652 return ATOB_ConvertAsciiToItem_Util(binary_item, ascii);
653 }
654
655 char *BTOA_ConvertItemToAscii(SECItem *binary_item)
656 {
657 return BTOA_ConvertItemToAscii_Util(binary_item);
658 }
659
660 NSSBase64Decoder *
661 NSSBase64Decoder_Create (PRInt32 (*output_fn) (void *, const unsigned char *,
662 PRInt32),
663 void *output_arg)
664 {
665 return NSSBase64Decoder_Create_Util(output_fn, output_arg);
666 }
667
668 NSSBase64Encoder *
669 NSSBase64Encoder_Create (PRInt32 (*output_fn) (void *, const char *, PRInt32),
670 void *output_arg)
671 {
672 return NSSBase64Encoder_Create_Util(output_fn, output_arg);
673 }
674
675 SECStatus
676 NSSBase64Decoder_Update (NSSBase64Decoder *data, const char *buffer,
677 PRUint32 size)
678 {
679 return NSSBase64Decoder_Update_Util(data, buffer, size);
680 }
681
682 SECStatus
683 NSSBase64Encoder_Update (NSSBase64Encoder *data, const unsigned char *buffer,
684 PRUint32 size)
685 {
686 return NSSBase64Encoder_Update_Util(data, buffer, size);
687 }
688
689 SECStatus
690 NSSBase64Decoder_Destroy (NSSBase64Decoder *data, PRBool abort_p)
691 {
692 return NSSBase64Decoder_Destroy_Util(data, abort_p);
693 }
694
695 SECStatus
696 NSSBase64Encoder_Destroy (NSSBase64Encoder *data, PRBool abort_p)
697 {
698 return NSSBase64Encoder_Destroy_Util(data, abort_p);
699 }
700
701 SECItem *
702 NSSBase64_DecodeBuffer (PLArenaPool *arenaOpt, SECItem *outItemOpt,
703 const char *inStr, unsigned int inLen)
704 {
705 return NSSBase64_DecodeBuffer_Util(arenaOpt, outItemOpt, inStr, inLen);
706 }
707
708 char *
709 NSSBase64_EncodeItem (PLArenaPool *arenaOpt, char *outStrOpt,
710 unsigned int maxOutLen, SECItem *inItem)
711 {
712 return NSSBase64_EncodeItem_Util(arenaOpt, outStrOpt, maxOutLen, inItem);
713 }
714
715 NSSRWLock* NSSRWLock_New(PRUint32 lock_rank, const char *lock_name)
716 {
717 return NSSRWLock_New_Util(lock_rank, lock_name);
718 }
719
720 void NSSRWLock_Destroy(NSSRWLock *lock)
721 {
722 NSSRWLock_Destroy_Util(lock);
723 }
724
725 void NSSRWLock_LockRead(NSSRWLock *lock)
726 {
727 NSSRWLock_LockRead_Util(lock);
728 }
729
730 void NSSRWLock_LockWrite(NSSRWLock *lock)
731 {
732 NSSRWLock_LockWrite_Util(lock);
733 }
734
735 void NSSRWLock_UnlockRead(NSSRWLock *lock)
736 {
737 NSSRWLock_UnlockRead_Util(lock);
738 }
739
740 void NSSRWLock_UnlockWrite(NSSRWLock *lock)
741 {
742 NSSRWLock_UnlockWrite_Util(lock);
743 }
744
745 PRBool NSSRWLock_HaveWriteLock(NSSRWLock *rwlock)
746 {
747 return NSSRWLock_HaveWriteLock_Util(rwlock);
748 }
749
750 SECStatus __nss_InitLock( PZLock **ppLock, nssILockType ltype )
751 {
752 PORT_SetError(PR_NOT_IMPLEMENTED_ERROR);
753 return SECFailure;
754 }
755
756 /* templates duplicated in libnss3 and libnssutil3 */
757
758 #undef NSS_Get_SEC_AnyTemplate
759 #undef NSS_Get_SEC_BitStringTemplate
760 #undef NSS_Get_SEC_BMPStringTemplate
761 #undef NSS_Get_SEC_BooleanTemplate
762 #undef NSS_Get_SEC_GeneralizedTimeTemplate
763 #undef NSS_Get_SEC_IA5StringTemplate
764 #undef NSS_Get_SEC_IntegerTemplate
765 #undef NSS_Get_SEC_NullTemplate
766 #undef NSS_Get_SEC_ObjectIDTemplate
767 #undef NSS_Get_SEC_OctetStringTemplate
768 #undef NSS_Get_SEC_PointerToAnyTemplate
769 #undef NSS_Get_SEC_PointerToOctetStringTemplate
770 #undef NSS_Get_SEC_SetOfAnyTemplate
771 #undef NSS_Get_SEC_UTCTimeTemplate
772 #undef NSS_Get_SEC_UTF8StringTemplate
773 #undef NSS_Get_SECOID_AlgorithmIDTemplate
774 #undef NSS_Get_sgn_DigestInfoTemplate
775 #undef SEC_AnyTemplate
776 #undef SEC_BitStringTemplate
777 #undef SEC_BMPStringTemplate
778 #undef SEC_BooleanTemplate
779 #undef SEC_GeneralizedTimeTemplate
780 #undef SEC_IA5StringTemplate
781 #undef SEC_IntegerTemplate
782 #undef SEC_NullTemplate
783 #undef SEC_ObjectIDTemplate
784 #undef SEC_OctetStringTemplate
785 #undef SEC_PointerToAnyTemplate
786 #undef SEC_PointerToOctetStringTemplate
787 #undef SEC_SetOfAnyTemplate
788 #undef SEC_UTCTimeTemplate
789 #undef SEC_UTF8StringTemplate
790 #undef SECOID_AlgorithmIDTemplate
791 #undef sgn_DigestInfoTemplate
792
793 #include "templates.c"
794
OLDNEW
« no previous file with comments | « nss/lib/nss/nssver.c ('k') | nss/lib/pk11wrap/debug_module.c » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698