e2sim/asn1c/constraints.c

   1 #include <asn_internal.h>
   2 #include <constraints.h>
   3
   4 int
   5 asn_generic_no_constraint(const asn_TYPE_descriptor_t *type_descriptor,
   6                           const void *struct_ptr,
   7                           asn_app_constraint_failed_f *cb, void *key) {
   8     (void)type_descriptor;      /* Unused argument */
   9         (void)struct_ptr;       /* Unused argument */
  10         (void)cb;       /* Unused argument */
  11         (void)key;      /* Unused argument */
  12
  13         /* Nothing to check */
  14         return 0;
  15 }
  16
  17 int
  18 asn_generic_unknown_constraint(const asn_TYPE_descriptor_t *type_descriptor,
  19                                const void *struct_ptr,
  20                                asn_app_constraint_failed_f *cb, void *key) {
  21     (void)type_descriptor;      /* Unused argument */
  22         (void)struct_ptr;       /* Unused argument */
  23         (void)cb;       /* Unused argument */
  24         (void)key;      /* Unused argument */
  25
  26         /* Unknown how to check */
  27         return 0;
  28 }
  29
  30 struct errbufDesc {
  31     const asn_TYPE_descriptor_t *failed_type;
  32     const void *failed_struct_ptr;
  33         char *errbuf;
  34         size_t errlen;
  35 };
  36
  37 static void
  38 CC_PRINTFLIKE(4, 5)
  39 _asn_i_ctfailcb(void *key, const asn_TYPE_descriptor_t *td, const void *sptr,
  40                 const char *fmt, ...) {
  41     struct errbufDesc *arg = key;
  42         va_list ap;
  43         ssize_t vlen;
  44         ssize_t maxlen;
  45
  46         arg->failed_type = td;
  47         arg->failed_struct_ptr = sptr;
  48
  49         maxlen = arg->errlen;
  50         if(maxlen <= 0)
  51                 return;
  52
  53         va_start(ap, fmt);
  54         vlen = vsnprintf(arg->errbuf, maxlen, fmt, ap);
  55         va_end(ap);
  56         if(vlen >= maxlen) {
  57                 arg->errbuf[maxlen-1] = '\0';   /* Ensuring libc correctness */
  58                 arg->errlen = maxlen - 1;       /* Not counting termination */
  59                 return;
  60         } else if(vlen >= 0) {
  61                 arg->errbuf[vlen] = '\0';       /* Ensuring libc correctness */
  62                 arg->errlen = vlen;             /* Not counting termination */
  63         } else {
  64                 /*
  65                  * The libc on this system is broken.
  66                  */
  67                 vlen = sizeof("<broken vsnprintf>") - 1;
  68                 maxlen--;
  69                 arg->errlen = vlen < maxlen ? vlen : maxlen;
  70                 memcpy(arg->errbuf, "<broken vsnprintf>", arg->errlen);
  71                 arg->errbuf[arg->errlen] = 0;
  72         }
  73
  74         return;
  75 }
  76
  77 int
  78 asn_check_constraints(const asn_TYPE_descriptor_t *type_descriptor,
  79                       const void *struct_ptr, char *errbuf, size_t *errlen) {
  80     struct errbufDesc arg;
  81     int ret;
  82
  83     arg.failed_type = 0;
  84     arg.failed_struct_ptr = 0;
  85     arg.errbuf = errbuf;
  86     arg.errlen = errlen ? *errlen : 0;
  87
  88     ret = type_descriptor->encoding_constraints.general_constraints(
  89         type_descriptor, struct_ptr, _asn_i_ctfailcb, &arg);
  90     if(ret == -1 && errlen) *errlen = arg.errlen;
  91
  92     return ret;
  93 }
  94