#include #include #include #define ARGV_DRIVER #include #include "sofort_driver_impl.h" #include "argv/argv.h" extern const struct argv_option sfrt_default_options[]; struct sfrt_driver_ctx_alloc { struct argv_meta * meta; struct sfrt_driver_ctx_impl ctx; uint64_t guard; const char * units[]; }; static uint32_t sfrt_argv_flags(uint32_t flags) { uint32_t ret = 0; if (flags & SFRT_DRIVER_VERBOSITY_NONE) ret |= ARGV_VERBOSITY_NONE; if (flags & SFRT_DRIVER_VERBOSITY_ERRORS) ret |= ARGV_VERBOSITY_ERRORS; if (flags & SFRT_DRIVER_VERBOSITY_STATUS) ret |= ARGV_VERBOSITY_STATUS; return ret; } static int sfrt_driver_usage( const char * program, const char * arg, const struct argv_option * options, struct argv_meta * meta) { char header[512]; snprintf(header,sizeof(header), "Usage: %s [options] ...\n" "Options:\n", program); argv_usage(stdout,header,options,arg); argv_free(meta); return SFRT_USAGE; } static struct sfrt_driver_ctx_impl * sfrt_driver_ctx_alloc( struct argv_meta * meta, const struct sfrt_common_ctx * cctx, size_t nunits) { struct sfrt_driver_ctx_alloc * ictx; size_t size; struct argv_entry * entry; const char ** units; size = sizeof(struct sfrt_driver_ctx_alloc); size += (nunits+1)*sizeof(const char *); if (!(ictx = calloc(size,1))) return 0; if (cctx) memcpy(&ictx->ctx.cctx,cctx,sizeof(*cctx)); for (entry=meta->entries,units=ictx->units; entry->fopt || entry->arg; entry++) if (!entry->fopt) *units++ = entry->arg; ictx->meta = meta; ictx->ctx.ctx.units = ictx->units; return &ictx->ctx; } int sfrt_get_driver_ctx_fail(struct argv_meta * meta) { argv_free(meta); return -1; } int sfrt_get_driver_ctx( const char ** argv, const char ** envp, uint32_t flags, struct sfrt_driver_ctx ** pctx) { struct sfrt_driver_ctx_impl * ctx; struct sfrt_common_ctx cctx; const struct argv_option * options; struct argv_meta * meta; struct argv_entry * entry; size_t nunits; const char * program; options = sfrt_default_options; if (!(meta = argv_get(argv,options,sfrt_argv_flags(flags)))) return -1; nunits = 0; program = argv_program_name(argv[0]); memset(&cctx,0,sizeof(cctx)); if (!argv[1] && (flags & SFRT_DRIVER_VERBOSITY_USAGE)) return sfrt_driver_usage(program,0,options,meta); /* get options, count units */ for (entry=meta->entries; entry->fopt || entry->arg; entry++) { if (entry->fopt) { switch (entry->tag) { case TAG_HELP: if (flags & SFRT_DRIVER_VERBOSITY_USAGE) return sfrt_driver_usage(program,entry->arg,options,meta); case TAG_VERSION: cctx.drvflags |= SFRT_DRIVER_VERSION; break; /* dummy */ /* dummy */ case TAG_OUTPUT_DUMMY: /* dummy */ cctx.anystring = entry->arg; /* dummy */ break; /* dummy */ /* dummy */ case TAG_OUTPUT_PROPERTY: /* dummy */ if (!(strcmp(entry->arg,"name"))) /* dummy */ cctx.actflags |= SFRT_OUTPUT_NAME; /* dummy */ else if (!(strcmp(entry->arg,"address"))) /* dummy */ cctx.actflags |= SFRT_OUTPUT_ADDRESS; /* dummy */ break; } } else nunits++; } if (!(ctx = sfrt_driver_ctx_alloc(meta,&cctx,nunits))) return sfrt_get_driver_ctx_fail(meta); ctx->ctx.program = program; ctx->ctx.cctx = &ctx->cctx; *pctx = &ctx->ctx; return SFRT_OK; } int sfrt_create_driver_ctx( const struct sfrt_common_ctx * cctx, struct sfrt_driver_ctx ** pctx) { struct argv_meta * meta; struct sfrt_driver_ctx_impl * ctx; const char * argv[] = {"sofort_driver",0}; if (!(meta = argv_get(argv,sfrt_default_options,0))) return -1; if (!(ctx = sfrt_driver_ctx_alloc(meta,cctx,0))) return sfrt_get_driver_ctx_fail(0); ctx->ctx.cctx = &ctx->cctx; memcpy(&ctx->cctx,cctx,sizeof(*cctx)); *pctx = &ctx->ctx; return SFRT_OK; } static void sfrt_free_driver_ctx_impl(struct sfrt_driver_ctx_alloc * ictx) { argv_free(ictx->meta); free(ictx); } void sfrt_free_driver_ctx(struct sfrt_driver_ctx * ctx) { struct sfrt_driver_ctx_alloc * ictx; uintptr_t addr; if (ctx) { addr = (uintptr_t)ctx - offsetof(struct sfrt_driver_ctx_alloc,ctx); addr = addr - offsetof(struct sfrt_driver_ctx_impl,ctx); ictx = (struct sfrt_driver_ctx_alloc *)addr; sfrt_free_driver_ctx_impl(ictx); } }