1 // Copyright (c) 2001-2009 Objective Systems, Inc. (http://www.obj-sys.com) 

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available 

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 

     9 /**

    10  * This file was generated by the Objective Systems ASN1C Compiler

    11  * (http://www.obj-sys.com).

    12  */

    13 #ifndef SUPL_INIT_H

    14 #define SUPL_INIT_H

    15 

    16 #include <stdio.h>

    17 #include <stdlib.h>

    18 #include "rtkey.h"

    19 #include "rtpersrc/asn1PerCppTypes.h"

    20 #include "ASN1CBitStr.h"

    21 #include "ULP-Components.h"

    22 

    23 /**

    24  * Header file for ASN.1 module SUPL-INIT

    25  */

    26 /**************************************************************/

    27 /*                                                            */

    28 /*  NotificationType                                          */

    29 /*                                                            */

    30 /**************************************************************/

    31 

    32 #define TV_NotificationType	(TM_UNIV|TM_PRIM|10)

    33 

    34 struct NotificationType {

    35    enum Root {

    36       noNotificationNoVerification = 0,

    37       notificationOnly = 1,

    38       notificationAndVerficationAllowedNA = 2,

    39       notificationAndVerficationDeniedNA = 3,

    40       privacyOverride = 4

    41    } ;

    42 } ;

    43 

    44 typedef OSUINT32 ASN1T_NotificationType;

    45 

    46 IMPORT_C int asn1PE_NotificationType (OSCTXT* pctxt, ASN1T_NotificationType value);

    47 

    48 IMPORT_C int asn1PD_NotificationType (OSCTXT* pctxt, ASN1T_NotificationType* pvalue);

    49 

    50 IMPORT_C void asn1Print_NotificationType

    51    (const char* name, ASN1T_NotificationType* pvalue);

    52 

    53 IMPORT_C const OSUTF8CHAR* ASN1T_NotificationType_ToString (OSINT32 value);

    54 

    55 IMPORT_C int ASN1T_NotificationType_ToEnum (OSCTXT* pctxt,

    56    const OSUTF8CHAR* value, ASN1T_NotificationType* pvalue);

    57 

    58 /**************************************************************/

    59 /*                                                            */

    60 /*  EncodingType                                              */

    61 /*                                                            */

    62 /**************************************************************/

    63 

    64 #define TV_EncodingType	(TM_UNIV|TM_PRIM|10)

    65 

    66 struct EncodingType {

    67    enum Root {

    68       ucs2 = 0,

    69       gsmDefault = 1,

    70       utf8 = 2

    71    } ;

    72 } ;

    73 

    74 typedef OSUINT32 ASN1T_EncodingType;

    75 

    76 IMPORT_C int asn1PE_EncodingType (OSCTXT* pctxt, ASN1T_EncodingType value);

    77 

    78 IMPORT_C int asn1PD_EncodingType (OSCTXT* pctxt, ASN1T_EncodingType* pvalue);

    79 

    80 IMPORT_C void asn1Print_EncodingType

    81    (const char* name, ASN1T_EncodingType* pvalue);

    82 

    83 IMPORT_C const OSUTF8CHAR* ASN1T_EncodingType_ToString (OSINT32 value);

    84 

    85 IMPORT_C int ASN1T_EncodingType_ToEnum (OSCTXT* pctxt,

    86    const OSUTF8CHAR* value, ASN1T_EncodingType* pvalue);

    87 

    88 /**************************************************************/

    89 /*                                                            */

    90 /*  Notification_requestorId                                  */

    91 /*                                                            */

    92 /**************************************************************/

    93 

    94 #define TV_Notification_requestorId	(TM_UNIV|TM_PRIM|4)

    95 

    96 struct ASN1T_Notification_requestorId {

    97    OSUINT32 numocts;

    98    OSOCTET data[50];

    99    // ctors

   100    ASN1T_Notification_requestorId () : numocts(0) {}

   101    ASN1T_Notification_requestorId (OSUINT32 _numocts, const OSOCTET* _data) :

   102       numocts (_numocts) {

   103       OSCRTLMEMCPY (data, _data, OSRTMIN (numocts, sizeof(data)));

   104    }

   105    ASN1T_Notification_requestorId (const char* cstring) {

   106       if (strlen(cstring) > 0) {

   107          numocts = OSRTMIN ((OSCRTLSTRLEN(cstring)+1), sizeof(data));

   108          OSCRTLSTRNCPY ((char*)data, cstring, sizeof(data));

   109       }

   110       else numocts = 0;

   111    }

   112    // assignment operators

   113    ASN1T_Notification_requestorId& operator= (const char* cstring) {

   114       if (strlen(cstring) > 0) {

   115          numocts = OSRTMIN ((OSCRTLSTRLEN(cstring)+1), sizeof(data));

   116          OSCRTLSTRNCPY ((char*)data, cstring, sizeof(data));

   117       }

   118       else numocts = 0;

   119       return *this;

   120    }

   121 } ;

   122 

   123 IMPORT_C int asn1PE_Notification_requestorId (OSCTXT* pctxt, ASN1T_Notification_requestorId* pvalue);

   124 

   125 IMPORT_C int asn1PD_Notification_requestorId (OSCTXT* pctxt, ASN1T_Notification_requestorId* pvalue);

   126 

   127 IMPORT_C void asn1Print_Notification_requestorId

   128    (const char* name, ASN1T_Notification_requestorId* pvalue);

   129 

   130 /**************************************************************/

   131 /*                                                            */

   132 /*  FormatIndicator                                           */

   133 /*                                                            */

   134 /**************************************************************/

   135 

   136 #define TV_FormatIndicator	(TM_UNIV|TM_PRIM|10)

   137 

   138 struct FormatIndicator {

   139    enum Root {

   140       logicalName = 0,

   141       e_mailAddress = 1,

   142       msisdn = 2,

   143       url = 3,

   144       sipUrl = 4,

   145       min = 5,

   146       mdn = 6

   147    } ;

   148 } ;

   149 

   150 typedef OSUINT32 ASN1T_FormatIndicator;

   151 

   152 IMPORT_C int asn1PE_FormatIndicator (OSCTXT* pctxt, ASN1T_FormatIndicator value);

   153 

   154 IMPORT_C int asn1PD_FormatIndicator (OSCTXT* pctxt, ASN1T_FormatIndicator* pvalue);

   155 

   156 IMPORT_C void asn1Print_FormatIndicator

   157    (const char* name, ASN1T_FormatIndicator* pvalue);

   158 

   159 IMPORT_C const OSUTF8CHAR* ASN1T_FormatIndicator_ToString (OSINT32 value);

   160 

   161 IMPORT_C int ASN1T_FormatIndicator_ToEnum (OSCTXT* pctxt,

   162    const OSUTF8CHAR* value, ASN1T_FormatIndicator* pvalue);

   163 

   164 /**************************************************************/

   165 /*                                                            */

   166 /*  Notification_clientName                                   */

   167 /*                                                            */

   168 /**************************************************************/

   169 

   170 #define TV_Notification_clientName	(TM_UNIV|TM_PRIM|4)

   171 

   172 struct ASN1T_Notification_clientName {

   173    OSUINT32 numocts;

   174    OSOCTET data[50];

   175    // ctors

   176    ASN1T_Notification_clientName () : numocts(0) {}

   177    ASN1T_Notification_clientName (OSUINT32 _numocts, const OSOCTET* _data) :

   178       numocts (_numocts) {

   179       OSCRTLMEMCPY (data, _data, OSRTMIN (numocts, sizeof(data)));

   180    }

   181    ASN1T_Notification_clientName (const char* cstring) {

   182       if (strlen(cstring) > 0) {

   183          numocts = OSRTMIN ((OSCRTLSTRLEN(cstring)+1), sizeof(data));

   184          OSCRTLSTRNCPY ((char*)data, cstring, sizeof(data));

   185       }

   186       else numocts = 0;

   187    }

   188    // assignment operators

   189    ASN1T_Notification_clientName& operator= (const char* cstring) {

   190       if (strlen(cstring) > 0) {

   191          numocts = OSRTMIN ((OSCRTLSTRLEN(cstring)+1), sizeof(data));

   192          OSCRTLSTRNCPY ((char*)data, cstring, sizeof(data));

   193       }

   194       else numocts = 0;

   195       return *this;

   196    }

   197 } ;

   198 

   199 IMPORT_C int asn1PE_Notification_clientName (OSCTXT* pctxt, ASN1T_Notification_clientName* pvalue);

   200 

   201 IMPORT_C int asn1PD_Notification_clientName (OSCTXT* pctxt, ASN1T_Notification_clientName* pvalue);

   202 

   203 IMPORT_C void asn1Print_Notification_clientName

   204    (const char* name, ASN1T_Notification_clientName* pvalue);

   205 

   206 /**************************************************************/

   207 /*                                                            */

   208 /*  Notification                                              */

   209 /*                                                            */

   210 /**************************************************************/

   211 

   212 #define TV_Notification	(TM_UNIV|TM_CONS|16)

   213 

   214 struct ASN1T_Notification {

   215    struct {

   216       unsigned encodingTypePresent : 1;

   217       unsigned requestorIdPresent : 1;

   218       unsigned requestorIdTypePresent : 1;

   219       unsigned clientNamePresent : 1;

   220       unsigned clientNameTypePresent : 1;

   221    } m;

   222    ASN1T_NotificationType notificationType;

   223    ASN1T_EncodingType encodingType;

   224    ASN1T_Notification_requestorId requestorId;

   225    ASN1T_FormatIndicator requestorIdType;

   226    ASN1T_Notification_clientName clientName;

   227    ASN1T_FormatIndicator clientNameType;

   228    IMPORT_C ASN1T_Notification ();

   229 } ;

   230 

   231 IMPORT_C int asn1PE_Notification (OSCTXT* pctxt, ASN1T_Notification* pvalue);

   232 

   233 IMPORT_C int asn1PD_Notification (OSCTXT* pctxt, ASN1T_Notification* pvalue);

   234 

   235 IMPORT_C void asn1Print_Notification

   236    (const char* name, ASN1T_Notification* pvalue);

   237 

   238 /**************************************************************/

   239 /*                                                            */

   240 /*  SLPMode                                                   */

   241 /*                                                            */

   242 /**************************************************************/

   243 

   244 #define TV_SLPMode	(TM_UNIV|TM_PRIM|10)

   245 

   246 struct SLPMode {

   247    enum Root {

   248       proxy = 0,

   249       nonProxy = 1

   250    } ;

   251 } ;

   252 

   253 typedef OSUINT32 ASN1T_SLPMode;

   254 

   255 IMPORT_C int asn1PE_SLPMode (OSCTXT* pctxt, ASN1T_SLPMode value);

   256 

   257 IMPORT_C int asn1PD_SLPMode (OSCTXT* pctxt, ASN1T_SLPMode* pvalue);

   258 

   259 IMPORT_C void asn1Print_SLPMode

   260    (const char* name, ASN1T_SLPMode* pvalue);

   261 

   262 IMPORT_C const OSUTF8CHAR* ASN1T_SLPMode_ToString (OSINT32 value);

   263 

   264 IMPORT_C int ASN1T_SLPMode_ToEnum (OSCTXT* pctxt,

   265    const OSUTF8CHAR* value, ASN1T_SLPMode* pvalue);

   266 

   267 /**************************************************************/

   268 /*                                                            */

   269 /*  MAC                                                       */

   270 /*                                                            */

   271 /**************************************************************/

   272 

   273 #define TV_MAC	(TM_UNIV|TM_PRIM|3)

   274 

   275 struct ASN1T_MAC {

   276    OSUINT32  numbits;

   277    OSOCTET data[8];

   278    // ctors

   279    ASN1T_MAC () : numbits(0) {}

   280    ASN1T_MAC (OSUINT32 _numbits, const OSOCTET* _data) :

   281       numbits(_numbits) {

   282       OSCRTLMEMCPY (data, _data, sizeof(data));

   283    }

   284 } ;

   285 

   286 IMPORT_C int asn1PE_MAC (OSCTXT* pctxt, ASN1T_MAC* pvalue);

   287 

   288 IMPORT_C int asn1PD_MAC (OSCTXT* pctxt, ASN1T_MAC* pvalue);

   289 

   290 IMPORT_C void asn1Print_MAC

   291    (const char* name, ASN1T_MAC* pvalue);

   292 

   293 /**************************************************************/

   294 /*                                                            */

   295 /*  KeyIdentity                                               */

   296 /*                                                            */

   297 /**************************************************************/

   298 

   299 #define TV_KeyIdentity	(TM_UNIV|TM_PRIM|3)

   300 

   301 struct ASN1T_KeyIdentity {

   302    OSUINT32  numbits;

   303    OSOCTET data[16];

   304    // ctors

   305    ASN1T_KeyIdentity () : numbits(0) {}

   306    ASN1T_KeyIdentity (OSUINT32 _numbits, const OSOCTET* _data) :

   307       numbits(_numbits) {

   308       OSCRTLMEMCPY (data, _data, sizeof(data));

   309    }

   310 } ;

   311 

   312 IMPORT_C int asn1PE_KeyIdentity (OSCTXT* pctxt, ASN1T_KeyIdentity* pvalue);

   313 

   314 IMPORT_C int asn1PD_KeyIdentity (OSCTXT* pctxt, ASN1T_KeyIdentity* pvalue);

   315 

   316 IMPORT_C void asn1Print_KeyIdentity

   317    (const char* name, ASN1T_KeyIdentity* pvalue);

   318 

   319 /**************************************************************/

   320 /*                                                            */

   321 /*  SUPLINIT                                                  */

   322 /*                                                            */

   323 /**************************************************************/

   324 

   325 #define TV_SUPLINIT	(TM_UNIV|TM_CONS|16)

   326 

   327 struct ASN1T_SUPLINIT {

   328    struct {

   329       unsigned notificationPresent : 1;

   330       unsigned sLPAddressPresent : 1;

   331       unsigned qoPPresent : 1;

   332       unsigned mACPresent : 1;

   333       unsigned keyIdentityPresent : 1;

   334    } m;

   335    ASN1T_PosMethod posMethod;

   336    ASN1T_Notification notification;

   337    ASN1T_SLPAddress sLPAddress;

   338    ASN1T_QoP qoP;

   339    ASN1T_SLPMode sLPMode;

   340    ASN1T_MAC mAC;

   341    ASN1T_KeyIdentity keyIdentity;

   342    IMPORT_C ASN1T_SUPLINIT ();

   343 } ;

   344 

   345 IMPORT_C int asn1PE_SUPLINIT (OSCTXT* pctxt, ASN1T_SUPLINIT* pvalue);

   346 

   347 IMPORT_C int asn1PD_SUPLINIT (OSCTXT* pctxt, ASN1T_SUPLINIT* pvalue);

   348 

   349 IMPORT_C void asn1Print_SUPLINIT

   350    (const char* name, ASN1T_SUPLINIT* pvalue);

   351 

   352 IMPORT_C void asn1Free_SUPLINIT (OSCTXT *pctxt, ASN1T_SUPLINIT* pvalue);

   353 

   354 #endif