自学教程：C++ GWEN_Buffer_free函数代码示例

int AH_User_SetPinStatus(AB_USER *u,			 const char *pin,			 GWEN_GUI_PASSWORD_STATUS status){  GWEN_BUFFER *nbuf;  int rv;  nbuf=GWEN_Buffer_new(0, 256 ,0 ,1);  AH_User_MkPinName(u, nbuf);  rv=GWEN_Gui_SetPasswordStatus(GWEN_Buffer_GetStart(nbuf),				pin,				status,				0);  GWEN_Buffer_free(nbuf);  return rv;}

AB_PROVIDER *AB_Provider_new(AB_BANKING *ab, const char *name){  AB_PROVIDER *pro;  GWEN_BUFFER *nbuf;  assert(ab);  assert(name);  nbuf=GWEN_Buffer_new(0, 256, 0, 1);  if (GWEN_Text_EscapeToBufferTolerant(name, nbuf)) {    DBG_ERROR(AQBANKING_LOGDOMAIN,              "Bad backend name, aborting.");    GWEN_Buffer_free(nbuf);    abort();  }  else {    char *s;    s=GWEN_Buffer_GetStart(nbuf);    while(*s) {      *s=tolower(*s);      s++;    }  }  GWEN_NEW_OBJECT(AB_PROVIDER, pro);  pro->usage=1;  GWEN_INHERIT_INIT(AB_PROVIDER, pro);  GWEN_LIST_INIT(AB_PROVIDER, pro);  pro->banking=ab;  pro->name=strdup(name);  pro->escName=strdup(GWEN_Buffer_GetStart(nbuf));  GWEN_Buffer_free(nbuf);  return pro;}

int AIO_OfxXmlCtx_SanitizeData(GWEN_XML_CONTEXT *ctx,			       const char *data,			       GWEN_BUFFER *buf) {  AIO_OFX_XMLCTX *xctx;  assert(ctx);  xctx=GWEN_INHERIT_GETDATA(GWEN_XML_CONTEXT, AIO_OFX_XMLCTX, ctx);  assert(xctx);  if (xctx->charset) {    GWEN_BUFFER *tbuf;    int rv;    tbuf=GWEN_Buffer_new(0, 256, 0, 1);    rv=AIO_OfxXmlCtx_CleanupData(ctx, data, tbuf);    if (rv<0) {      DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);      GWEN_Buffer_free(tbuf);      return rv;    }    rv=GWEN_Text_ConvertCharset(xctx->charset, "UTF-8",				GWEN_Buffer_GetStart(tbuf),				GWEN_Buffer_GetUsedBytes(tbuf),				buf);    if (rv<0) {      DBG_INFO(AQBANKING_LOGDOMAIN, "here (%d)", rv);      GWEN_Buffer_free(tbuf);      return rv;    }    GWEN_Buffer_free(tbuf);    return 0;  }  else    return AIO_OfxXmlCtx_CleanupData(ctx, data, buf);}

int GWEN_Logger_Log(const char *logDomain,                    GWEN_LOGGER_LEVEL priority, const char *s) {  if (!GWEN_Gui_LogHook(logDomain, priority, s)) {    const char *p;    int rv;    unsigned int i;    GWEN_BUFFER *mbuf;    GWEN_LOGGER *lg;    lg=GWEN_LoggerDomain_GetLogger(logDomain);    assert(lg);    if (!lg->enabled)      return 1;    if (priority>lg->logLevel)      /* priority too low, don't log */      return 0;    /* temporarily disable logging to avoid endless loops */    lg->enabled=0;    /* copy buffer, exchange all newlines by 0 */    mbuf=GWEN_Buffer_new(0, strlen(s)+1, 0, 1);    for (i=0; i<strlen(s)+1; i++) {      if (s[i]=='/n') {        GWEN_Buffer_AppendByte(mbuf, 0);      }      else        GWEN_Buffer_AppendByte(mbuf, s[i]);    }    /* now log each line */    rv=0;    p=GWEN_Buffer_GetStart(mbuf);    while (*p) {      rv|=GWEN_Logger__Log(lg, priority, p);      while(*p)        p++;      p++;    }    GWEN_Buffer_free(mbuf);    /* reenable logging */    lg->enabled=1;    return rv;  }  else    return 0;}

int GWEN_XML_AddNameSpace(GWEN_STRINGLIST2 *sl,                          const char *prefix,                          const char *name) {  GWEN_BUFFER *nbuf;  int rv;  nbuf=GWEN_Buffer_new(0, 32, 0, 1);  if (prefix)    GWEN_Buffer_AppendString(nbuf, prefix);  GWEN_Buffer_AppendByte(nbuf, ':');  GWEN_Buffer_AppendString(nbuf, name);  rv=GWEN_StringList2_AppendString(sl, GWEN_Buffer_GetStart(nbuf), 0,                                   GWEN_StringList2_IntertMode_NoDouble);  GWEN_Buffer_free(nbuf);  return rv;}

void AB_Value_Dump(const AB_VALUE *v, FILE *f, unsigned int indent) {  unsigned int i;  for (i=0; i<indent; i++)    fprintf(f, " ");  fprintf(f, "Value: ");  if (v) {    GWEN_BUFFER *nbuf;    nbuf=GWEN_Buffer_new(0, 128, 0, 1);    AB_Value_toHumanReadableString(v, nbuf, 2);    gmp_fprintf(f, "%Qi (%s)/n", v->value, GWEN_Buffer_GetStart(nbuf));    GWEN_Buffer_free(nbuf);  }  else    fprintf(f, "[none]/n");}

int GWEN_Directory_GetFileEntries(const char *folder, GWEN_STRINGLIST *sl,                                  const char *mask) {  GWEN_DIRECTORY *d;  int rv;  char buffer[256];  GWEN_BUFFER *pbuf;  uint32_t pos;  d=GWEN_Directory_new();  rv=GWEN_Directory_Open(d, folder);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_Directory_free(d);    return rv;  }  pbuf=GWEN_Buffer_new(0, 256, 0, 1);  GWEN_Buffer_AppendString(pbuf, folder);  GWEN_Buffer_AppendString(pbuf, GWEN_DIR_SEPARATOR_S);  pos=GWEN_Buffer_GetPos(pbuf);  while(0==GWEN_Directory_Read(d, buffer, sizeof(buffer))) {    if (strcmp(buffer, ".")!=0 &&        strcmp(buffer, "..")!=0 &&        (mask==NULL ||         GWEN_Text_ComparePattern(buffer+1, mask, 0)!=-1)) {      struct stat st;      GWEN_Buffer_AppendString(pbuf, buffer);      if (stat(GWEN_Buffer_GetStart(pbuf), &st)==0) {        if (S_ISREG(st.st_mode))          GWEN_StringList_AppendString(sl, buffer, 0, 1);      }      GWEN_Buffer_Crop(pbuf, 0, pos);    }  }  GWEN_Buffer_free(pbuf);  GWEN_Directory_Close(d);  GWEN_Directory_free(d);  return 0;}

int AHB_DTAUS__AddWord(GWEN_BUFFER *dst,                       unsigned int size,                       const char *s) {  unsigned int i;  unsigned int ssize;  GWEN_BUFFER *nbuf;  assert(dst);  assert(size);  assert(s);  DBG_DEBUG(AQBANKING_LOGDOMAIN, "Adding word: %s", s);  nbuf=GWEN_Buffer_new(0, size, 0, 1);  AB_ImExporter_Utf8ToDta(s, -1, nbuf);  s=GWEN_Buffer_GetStart(nbuf);  ssize=strlen(s);  if (ssize>size) {    /* Error out here because e.g. truncated accountid will lead to failed jobs. */    DBG_ERROR(AQBANKING_LOGDOMAIN, "Word /"%s/" too long: Has length %d but must not be longer than %d characters",	      s, ssize, size);    return -1;  }  for (i=0; i<size; i++) {    char c;    if (i>=ssize)      c=0;    else      c=s[i];    if (c)      GWEN_Buffer_AppendByte(dst, c);    else      GWEN_Buffer_AppendByte(dst, ' ');  } /* for */  GWEN_Buffer_free(nbuf);  return 0;}

GWEN_DB_NODE *AH_User_GetUpdForAccountIdAndSuffix(const AB_USER *u,                                                  const char *sAccountNumber,                                                  const char *sAccountSuffix) {  AH_USER *ue;  GWEN_DB_NODE *db;  GWEN_BUFFER *tbuf;  assert(u);  ue=GWEN_INHERIT_GETDATA(AB_USER, AH_USER, u);  assert(ue);  db=AH_User_GetUpd(u);  if (db==NULL) {    DBG_INFO(AQHBCI_LOGDOMAIN, "No upd");    return NULL;  }  tbuf=GWEN_Buffer_new(0, 64, 0, 1);  GWEN_Buffer_AppendString(tbuf, sAccountNumber);  GWEN_Buffer_AppendString(tbuf, "-");  /* take into account the "Unterkontomerkmal", don't rely solely on account id */  if (sAccountSuffix && *sAccountSuffix)    GWEN_Buffer_AppendString(tbuf, sAccountSuffix);  else    GWEN_Buffer_AppendString(tbuf, "none");  DBG_INFO(AQHBCI_LOGDOMAIN, "Checking upd for account /"%s/"", GWEN_Buffer_GetStart(tbuf));  db=GWEN_DB_GetGroup(db,                      GWEN_PATH_FLAGS_NAMEMUSTEXIST,                      GWEN_Buffer_GetStart(tbuf));  GWEN_Buffer_free(tbuf);  if (db==NULL) {    DBG_INFO(AQHBCI_LOGDOMAIN, "Falling back to old storage of UPD for account /"%s/"", sAccountNumber);    db=AH_User_GetUpd(u);    db=GWEN_DB_GetGroup(db,                        GWEN_PATH_FLAGS_NAMEMUSTEXIST,                        sAccountNumber);  }  return db;}

int AH_NewKeyFileDialog_HandleActivatedFileButton(GWEN_DIALOG *dlg) {  AH_NEWKEYFILE_DIALOG *xdlg;  int rv;  const char *s;  GWEN_BUFFER *pathBuffer;  assert(dlg);  xdlg=GWEN_INHERIT_GETDATA(GWEN_DIALOG, AH_NEWKEYFILE_DIALOG, dlg);  assert(xdlg);  pathBuffer=GWEN_Buffer_new(0, 256, 0, 1);  s=GWEN_Dialog_GetCharProperty(dlg, "wiz_filename_edit", GWEN_DialogProperty_Value, 0, NULL);  if (s && *s)    GWEN_Buffer_AppendString(pathBuffer, s);  rv=GWEN_Gui_GetFileName(I18N("Create Keyfile"),			  GWEN_Gui_FileNameType_SaveFileName,			  0,			  I18N("All Files (*)/tOHBCI Files (*ohbci;*.medium)"),			  pathBuffer,			  GWEN_Dialog_GetGuiId(dlg));  if (rv==0) {    GWEN_Dialog_SetCharProperty(dlg,				"wiz_filename_edit",				GWEN_DialogProperty_Value,				0,				GWEN_Buffer_GetStart(pathBuffer),				0);    rv=AH_NewKeyFileDialog_GetFilePageData(dlg);    if (rv<0)      GWEN_Dialog_SetIntProperty(dlg, "wiz_next_button", GWEN_DialogProperty_Enabled, 0, 0, 0);    else      GWEN_Dialog_SetIntProperty(dlg, "wiz_next_button", GWEN_DialogProperty_Enabled, 0, 1, 0);  }  else {    DBG_NOTICE(AQHBCI_LOGDOMAIN, "here (%d)", rv);  }  GWEN_Buffer_free(pathBuffer);  return GWEN_DialogEvent_ResultHandled;}

int GWEN_Crypt_Token_ModuleInit(void){  GWEN_PLUGIN_MANAGER *pm;  int err;  GWEN_STRINGLIST *sl;  pm=GWEN_PluginManager_new(GWEN_CRYPT_TOKEN_PLUGIN_TYPENAME, GWEN_PM_LIBNAME);  err=GWEN_PluginManager_Register(pm);  if (err) {    DBG_ERROR(GWEN_LOGDOMAIN, "Could not register CryptToken plugin manager");    return err;  }  /* create plugin paths */  sl=GWEN_PathManager_GetPaths(GWEN_PM_LIBNAME, GWEN_PM_PLUGINDIR);  if (sl) {    GWEN_STRINGLISTENTRY *se;    GWEN_BUFFER *pbuf;    pbuf=GWEN_Buffer_new(0, 256, 0, 1);    se=GWEN_StringList_FirstEntry(sl);    while (se) {      GWEN_Buffer_AppendString(pbuf, GWEN_StringListEntry_Data(se));      GWEN_Buffer_AppendString(pbuf, DIRSEP GWEN_CRYPT_TOKEN_FOLDER);      DBG_INFO(GWEN_LOGDOMAIN, "Adding plugin path [%s]",               GWEN_Buffer_GetStart(pbuf));      GWEN_PluginManager_AddPath(pm, GWEN_PM_LIBNAME,                                 GWEN_Buffer_GetStart(pbuf));      GWEN_Buffer_Reset(pbuf);      se=GWEN_StringListEntry_Next(se);    }    GWEN_Buffer_free(pbuf);    GWEN_StringList_free(sl);  }  return 0;}

int GWEN_PathManager_AddPath(const char *callingLib,                             const char *destLib,                             const char *pathName,                             const char *pathValue) {  GWEN_DB_NODE *dbT;  GWEN_BUFFER *buf;  assert(destLib);  assert(pathName);  assert(pathValue);  assert(gwen__paths);  dbT=GWEN_DB_GetGroup(gwen__paths, GWEN_PATH_FLAGS_NAMEMUSTEXIST,                       destLib);  if (!dbT)    return GWEN_ERROR_NOT_FOUND;  dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_NAMEMUSTEXIST,                       pathName);  if (!dbT)    return GWEN_ERROR_NOT_FOUND;  dbT=GWEN_DB_GetGroup(dbT, GWEN_PATH_FLAGS_CREATE_GROUP,                       "pair");  assert(dbT);  if (callingLib) {    GWEN_DB_SetCharValue(dbT, GWEN_DB_FLAGS_DEFAULT,                         "lib", callingLib);  }  buf=GWEN_Buffer_new(0, 256, 0, 1);  GWEN_Directory_OsifyPath(pathValue, buf, 1);  GWEN_DB_SetCharValue(dbT, GWEN_DB_FLAGS_DEFAULT,                       "path",                       GWEN_Buffer_GetStart(buf));  GWEN_Buffer_free(buf);  return 0;}

LC_CLIENT_RESULT CHIPCARD_CB LC_DDVCard_Open(LC_CARD *card){  LC_CLIENT_RESULT res;  LC_DDVCARD *ddv;  DBG_INFO(LC_LOGDOMAIN, "Opening card as DDV card");  assert(card);  ddv=GWEN_INHERIT_GETDATA(LC_CARD, LC_DDVCARD, card);  assert(ddv);  ddv->ddvType=-1;  GWEN_DB_Group_free(ddv->db_ef_id_1);  ddv->db_ef_id_1=0;  GWEN_Buffer_free(ddv->bin_ef_id_1);  ddv->bin_ef_id_1=0;  if (strcasecmp(LC_Card_GetCardType(card), "PROCESSOR")!=0) {    DBG_ERROR(LC_LOGDOMAIN, "Not a processor card (%s)",              LC_Card_GetCardType(card));    return LC_Client_ResultNotSupported;  }  res=ddv->openFn(card);  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    return res;  }  res=LC_DDVCard_Reopen(card);  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    ddv->closeFn(card);    return res;  }  return LC_Client_ResultOk;}

void GWEN_DBIO__XmlDb_ReadDataTags(GWEN_XMLNODE *node, GWEN_BUFFER *buf) {  GWEN_XMLNODE *ndata;  GWEN_BUFFER *tbuf;  int rv;  tbuf=GWEN_Buffer_new(0, 256, 0, 1);  ndata=GWEN_XMLNode_GetFirstData(node);  while(ndata) {    const char *s;    s=GWEN_XMLNode_GetData(ndata);    if (s) {      if (GWEN_Buffer_GetUsedBytes(tbuf))	GWEN_Buffer_AppendByte(tbuf, ' ');      GWEN_Buffer_AppendString(tbuf, s);    }    ndata=GWEN_XMLNode_GetNextData(node);  }  rv=GWEN_Text_UnescapeXmlToBuffer(GWEN_Buffer_GetStart(tbuf), buf);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);  }  GWEN_Buffer_free(tbuf);}

static int addToList(const char *fname, int recursive, GWEN_STRINGLIST *sl) {  struct stat st;  int rv;  /* stat file to be added */#if _BSD_SOURCE || _XOPEN_SOURCE >= 500 || _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED  rv=lstat(fname, &st);#else  rv=stat(fname, &st);#endif  if (rv) {    DBG_ERROR(GSA_LOGDOMAIN, "stat(%s): %d (%s)",              fname, errno, strerror(errno));    fprintf(stderr, "Ignoring file /"%s/"/n", fname);  }  else {    /* always append this entry */    GWEN_StringList_AppendString(sl, fname, 0, 1);    if (recursive && S_ISDIR(st.st_mode)) {      GWEN_STRINGLIST *sll;      GWEN_STRINGLISTENTRY *se;      GWEN_DIRECTORY *d;      int rv;      char buffer[256];      GWEN_BUFFER *tbuf;      uint32_t pos;      /* add entries */      sll=GWEN_StringList_new();      d=GWEN_Directory_new();      rv=GWEN_Directory_Open(d, fname);      if (rv<0) {        DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);        GWEN_Directory_free(d);        GWEN_StringList_free(sll);        return rv;      }      while(0==GWEN_Directory_Read(d, buffer, sizeof(buffer))) {        if (strcmp(buffer, ".")!=0 &&            strcmp(buffer, "..")!=0)          GWEN_StringList_AppendString(sll, buffer, 0, 1);      }      GWEN_Directory_Close(d);      GWEN_Directory_free(d);      /* recurse */      tbuf=GWEN_Buffer_new(0, 256, 0, 1);      GWEN_Buffer_AppendString(tbuf, fname);      GWEN_Buffer_AppendString(tbuf, GWEN_DIR_SEPARATOR_S);      pos=GWEN_Buffer_GetPos(tbuf);      se=GWEN_StringList_FirstEntry(sll);      while(se) {        const char *s;        s=GWEN_StringListEntry_Data(se);        if (s && *s) {          GWEN_Buffer_AppendString(tbuf, s);          rv=addToList(GWEN_Buffer_GetStart(tbuf), recursive, sl);          if (rv<0) {            DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);            GWEN_Buffer_free(tbuf);            GWEN_StringList_free(sll);            return rv;          }        }        GWEN_Buffer_Crop(tbuf, 0, pos);        se=GWEN_StringListEntry_Next(se);      } /* while se */      GWEN_Buffer_free(tbuf);      GWEN_StringList_free(sll);    } /* if dir and recursive */  } /* if stat was ok */  return 0;}

int add2Archive(GWEN_DB_NODE *dbArgs, int argc, char **argv) {  GWEN_DB_NODE *db;  const char *aname;  GWEN_SAR *sr;  int rv;  int recursive;  int verbosity;  const GWEN_ARGS args[]={  {    GWEN_ARGS_FLAGS_HAS_ARGUMENT,     /* flags */    GWEN_ArgsType_Char,               /* type */    "archive",                        /* name */    1,                                /* minnum */    1,                                /* maxnum */    "a",                              /* short option */    "archive",                        /* long option */    "Specify the archive file name",  /* short description */    "Specify the archive file name"   /* long description */  },  {    0, /* flags */    GWEN_ArgsType_Int,                /* type */    "recursive",                      /* name */    0,                                /* minnum */    1,                                /* maxnum */    "r",                              /* short option */    "recursive",                      /* long option */    "add folders recursively",        /* short description */    "add folders recursively"         /* long description */  },  {    0, /* flags */    GWEN_ArgsType_Int,                /* type */    "verbosity",                      /* name */    0,                                /* minnum */    10,                                /* maxnum */    "v",                              /* short option */    NULL,                             /* long option */    "set verbosity",                  /* short description */    "set verbosity"                   /* long description */  },  {    GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */    GWEN_ArgsType_Int,             /* type */    "help",                       /* name */    0,                            /* minnum */    0,                            /* maxnum */    "h",                          /* short option */    "help",                       /* long option */    "Show this help screen",      /* short description */    "Show this help screen"       /* long description */  }  };  db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local");  rv=GWEN_Args_Check(argc, argv, 1,                     GWEN_ARGS_MODE_ALLOW_FREEPARAM,                     args,                     db);  if (rv==GWEN_ARGS_RESULT_ERROR) {    fprintf(stderr, "ERROR: Could not parse arguments/n");    return 1;  }  else if (rv==GWEN_ARGS_RESULT_HELP) {    GWEN_BUFFER *ubuf;    ubuf=GWEN_Buffer_new(0, 1024, 0, 1);    if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {      fprintf(stderr, "ERROR: Could not create help string/n");      return 1;    }    fprintf(stderr, "%s/n", GWEN_Buffer_GetStart(ubuf));    GWEN_Buffer_free(ubuf);    return 0;  }  aname=GWEN_DB_GetCharValue(db, "archive", 0, NULL);  assert(aname);  recursive=GWEN_DB_GetIntValue(db, "recursive", 0, 0);  verbosity=GWEN_DB_GetIntValue(db, "verbosity", 0, 0);  sr=GWEN_Sar_new();  rv=GWEN_Sar_OpenArchive(sr, aname,                          GWEN_SyncIo_File_CreationMode_OpenExisting,                          GWEN_SYNCIO_FILE_FLAGS_READ|GWEN_SYNCIO_FILE_FLAGS_WRITE);  if (rv<0) {    fprintf(stderr, "ERROR: Error opening archive (%d)/n", rv);    return 2;  }  else {    int i;    GWEN_STRINGLIST *sl;    GWEN_STRINGLISTENTRY *se;    sl=GWEN_StringList_new();    for (i=0; ; i++) {      const char *fname;      fname=GWEN_DB_GetCharValue(db, "params", i, 0);//.........这里部分代码省略.........

int main(int argc, char **argv) {  int rv;  GWEN_DB_NODE *db;  const char *s;  LC_CLIENT *cl;  LC_CLIENT_RESULT res;  GWEN_GUI *gui;  int v;  gui=GWEN_Gui_CGui_new();  GWEN_Gui_SetGui(gui);  db=GWEN_DB_Group_new("arguments");  rv=GWEN_Args_Check(argc, argv, 1,                     GWEN_ARGS_MODE_ALLOW_FREEPARAM,                     prg_args,                     db);  if (rv==GWEN_ARGS_RESULT_HELP) {    GWEN_BUFFER *ubuf;    ubuf=GWEN_Buffer_new(0, 256, 0, 1);    if (GWEN_Args_Usage(prg_args, ubuf, GWEN_ArgsOutType_Txt)) {      fprintf(stderr, "Could not generate usage string./n");      GWEN_Buffer_free(ubuf);      return RETURNVALUE_PARAM;    }    usage(argv[0], GWEN_Buffer_GetStart(ubuf));    GWEN_Buffer_free(ubuf);    return 0;  }  if (rv<1) {    fprintf(stderr, "ERROR: Error in argument list (%d)/n", rv);    return RETURNVALUE_PARAM;  }  v=GWEN_DB_GetIntValue(db, "verbosity", 0, 0);  if (v<2)    GWEN_Gui_AddFlags(gui, GWEN_GUI_FLAGS_NONINTERACTIVE);  /* get command */  s=GWEN_DB_GetCharValue(db, "params", 0, 0);  if (!s) {    fprintf(stderr, "No command given./n");    GWEN_DB_Group_free(db);    return RETURNVALUE_PARAM;  }  cl=LC_Client_new("kvkcard", PROGRAM_VERSION);  res=LC_Client_Init(cl);  if (res!=LC_Client_ResultOk) {    showError(0, res, "Init");    return RETURNVALUE_SETUP;  }  /* handle command */  if (strcasecmp(s, "read")==0) {    rv=kvkRead(cl, db);  }  else if (strcasecmp(s, "daemon")==0) {    fprintf(stderr, "KVK daemon no longer supported./n");    return RETURNVALUE_SETUP;  }  else if (strcasecmp(s, "rdvd")==0) {    rv=rdvd(cl, db);  }  else if (strcasecmp(s, "rdpd")==0) {    rv=rdpd(cl, db);  }  else if (strcasecmp(s, "psvd")==0) {    rv=psvd(cl, db);  }  else {    fprintf(stderr, "Unknown command /"%s/"", s);    rv=RETURNVALUE_PARAM;  }  LC_Client_free(cl);  GWEN_DB_Group_free(db);  return 0;}

LC_CLIENT_RESULT LC_ZkaCard_Reopen(LC_CARD *card) {  LC_CLIENT_RESULT res;  LC_ZKACARD *xc;  GWEN_BUFFER *mbuf;  DBG_INFO(LC_LOGDOMAIN, "Opening ZkaCard card");  assert(card);  xc=GWEN_INHERIT_GETDATA(LC_CARD, LC_ZKACARD, card);  assert(xc);  LC_Card_SetLastResult(card, 0, 0, 0, 0);  GWEN_Buffer_free(xc->bin_ef_gd_0);  xc->bin_ef_gd_0=NULL;  GWEN_Buffer_free(xc->bin_ef_id);  xc->bin_ef_id=NULL;  GWEN_Buffer_free(xc->bin_ef_ssd);  xc->bin_ef_ssd=NULL;  res=LC_Card_SelectCard(card, "zkacard");  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    return res;  }  /* first select generic app for all ZKACARD HBCI cards */  res=LC_Card_SelectApp(card, "zkacard");  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    return res;  }  DBG_INFO(LC_LOGDOMAIN, "Selecting MF...");  res=LC_Card_SelectMf(card);  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    return res;  }  /* read EF_ID */  DBG_INFO(LC_LOGDOMAIN, "Selecting EF_ID...");  res=LC_Card_SelectEf(card, "EF_ID");  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    return res;  }  DBG_INFO(LC_LOGDOMAIN, "Reading record...");  mbuf=GWEN_Buffer_new(0, 32, 0, 1);  res=LC_Card_IsoReadRecord(card, LC_CARD_ISO_FLAGS_RECSEL_GIVEN, 1, mbuf);  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    GWEN_Buffer_free(mbuf);    return res;  }  xc->bin_ef_id=mbuf;  /* read EG_GD0 */  DBG_INFO(LC_LOGDOMAIN, "Selecting EF_GD0...");  res=LC_Card_SelectEf(card, "EF_GD0");  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    return res;  }  DBG_INFO(LC_LOGDOMAIN, "Reading data...");  mbuf=GWEN_Buffer_new(0, 16, 0, 1);  res=LC_Card_IsoReadBinary(card, 0, 0, 12, mbuf);  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    GWEN_Buffer_free(mbuf);    return res;  }  if (GWEN_Buffer_GetUsedBytes(mbuf)<12) {    DBG_INFO(LC_LOGDOMAIN, "here");    GWEN_Buffer_free(mbuf);    return LC_Client_ResultDataError;  }  xc->bin_ef_gd_0=mbuf;  /* select DF_SIG */  DBG_INFO(LC_LOGDOMAIN, "Selecting DF_SIG...");  res=LC_Card_SelectDf(card, "DF_SIG");  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    return res;  }  /* read EG_SSD */  DBG_INFO(LC_LOGDOMAIN, "Selecting EF_SSD...");  res=LC_Card_SelectEf(card, "EF_SSD");  if (res!=LC_Client_ResultOk) {    DBG_INFO(LC_LOGDOMAIN, "here");    return res;  }//.........这里部分代码省略.........

GWENHYWFAR_CBint GWEN_CryptMgrKeys_VerifyData(GWEN_CRYPTMGR *cm,                                 const uint8_t *pData, uint32_t lData,                                 const uint8_t *pSignature, uint32_t lSignature) {  GWEN_CRYPTMGR_KEYS *xcm;  GWEN_MDIGEST *md;  int rv;  GWEN_BUFFER *tbuf;  int ksize;  uint32_t l;  assert(cm);  xcm=GWEN_INHERIT_GETDATA(GWEN_CRYPTMGR, GWEN_CRYPTMGR_KEYS, cm);  assert(xcm);  if (xcm->peerKey==NULL) {    DBG_ERROR(GWEN_LOGDOMAIN, "No peer key");    return GWEN_ERROR_GENERIC;  }  ksize=GWEN_Crypt_Key_GetKeySize(xcm->peerKey);  /* the padding algo uses random numbers, so we must use the encrypt function and   * compare the decoded and unpadded signature with the hash of the source data   */  tbuf=GWEN_Buffer_new(0, ksize+16, 0, 1);  l=GWEN_Buffer_GetMaxUnsegmentedWrite(tbuf);  rv=GWEN_Crypt_Key_Encipher(xcm->peerKey,                             pSignature, lSignature,                             (uint8_t*)GWEN_Buffer_GetPosPointer(tbuf),                             &l);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_Buffer_free(tbuf);    return rv;  }  GWEN_Buffer_IncrementPos(tbuf, l);  GWEN_Buffer_AdjustUsedBytes(tbuf);  /* unpadd */  rv=GWEN_Padd_UnpaddWithIso9796_2(tbuf);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_Buffer_free(tbuf);    return rv;  }  /* tbuf now contains the hash */  /* hash source data */  md=GWEN_MDigest_Rmd160_new();  rv=GWEN_MDigest_Begin(md);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_MDigest_free(md);    GWEN_Buffer_free(tbuf);    return rv;  }  rv=GWEN_MDigest_Update(md, pData, lData);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_MDigest_free(md);    GWEN_Buffer_free(tbuf);    return rv;  }  rv=GWEN_MDigest_End(md);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_MDigest_free(md);    GWEN_Buffer_free(tbuf);    return rv;  }  if (GWEN_MDigest_GetDigestSize(md)!=GWEN_Buffer_GetUsedBytes(tbuf)) {    DBG_ERROR(GWEN_LOGDOMAIN, "Invalid signature");    GWEN_MDigest_free(md);    GWEN_Buffer_free(tbuf);    return GWEN_ERROR_VERIFY;  }  if (memcmp(GWEN_MDigest_GetDigestPtr(md),             GWEN_Buffer_GetStart(tbuf),             GWEN_MDigest_GetDigestSize(md))!=0) {    DBG_ERROR(GWEN_LOGDOMAIN, "Invalid signature");    GWEN_MDigest_free(md);    GWEN_Buffer_free(tbuf);    return GWEN_ERROR_VERIFY;  }  GWEN_MDigest_free(md);  GWEN_Buffer_free(tbuf);  return 0;}

GWENHYWFAR_CBint GWEN_CryptMgrKeys_SignData(GWEN_CRYPTMGR *cm,                               const uint8_t *pData, uint32_t lData,                               GWEN_BUFFER *dbuf) {  GWEN_CRYPTMGR_KEYS *xcm;  GWEN_MDIGEST *md;  int rv;  GWEN_BUFFER *tbuf;  int ksize;  uint32_t signatureLen;  assert(cm);  xcm=GWEN_INHERIT_GETDATA(GWEN_CRYPTMGR, GWEN_CRYPTMGR_KEYS, cm);  assert(xcm);  if (xcm->localKey==NULL) {    DBG_ERROR(GWEN_LOGDOMAIN, "No local key");    return GWEN_ERROR_GENERIC;  }  ksize=GWEN_Crypt_Key_GetKeySize(xcm->localKey);  /* hash pData */  md=GWEN_MDigest_Rmd160_new();  rv=GWEN_MDigest_Begin(md);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_MDigest_free(md);    return rv;  }  rv=GWEN_MDigest_Update(md, pData, lData);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_MDigest_free(md);    return rv;  }  rv=GWEN_MDigest_End(md);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    GWEN_MDigest_free(md);    return rv;  }  /* padd */  tbuf=GWEN_Buffer_new(0, ksize, 0, 1);  GWEN_Buffer_AppendBytes(tbuf,                          (const char*)GWEN_MDigest_GetDigestPtr(md),                          GWEN_MDigest_GetDigestSize(md));  GWEN_MDigest_free(md);  GWEN_Padd_PaddWithIso9796_2(tbuf, ksize);  /* sign */  GWEN_Buffer_AllocRoom(dbuf, ksize);  signatureLen=GWEN_Buffer_GetMaxUnsegmentedWrite(dbuf);  rv=GWEN_Crypt_Key_Sign(xcm->localKey,                         (uint8_t*)GWEN_Buffer_GetStart(tbuf),                         GWEN_Buffer_GetUsedBytes(tbuf),                         (uint8_t*)GWEN_Buffer_GetPosPointer(dbuf),                         &signatureLen);  GWEN_Buffer_free(tbuf);  if (rv<0) {    DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);    return rv;  }  GWEN_Buffer_IncrementPos(dbuf, signatureLen);  GWEN_Buffer_AdjustUsedBytes(dbuf);  return 0;}

AB_IMEXPORTER_ACCOUNTINFO *AB_ImExporterYN__ReadAccountInfo(AB_IMEXPORTER *ie,                                                            AB_IMEXPORTER_CONTEXT *ctx,                                                            GWEN_XMLNODE *doc){  GWEN_XMLNODE *n;  AB_IMEXPORTER_ACCOUNTINFO *ai;  ai=AB_ImExporterAccountInfo_new();  n=GWEN_XMLNode_FindFirstTag(doc, "SG2", 0, 0);  if (n)    n=GWEN_XMLNode_FindFirstTag(n, "FII", 0, 0);  if (n) {    GWEN_XMLNODE *nn;    const char *s;    nn=GWEN_XMLNode_FindFirstTag(n, "C078", 0, 0);    if (nn) {      GWEN_XMLNODE *nnn;      /* account number */      s=GWEN_XMLNode_GetCharValue(nn, "D_3194", 0);      if (s)        AB_ImExporterAccountInfo_SetAccountNumber(ai, s);      /* IBAN */      s=GWEN_XMLNode_GetCharValue(nn, "D_3192", 0);      if (s)        AB_ImExporterAccountInfo_SetIban(ai, s);      /* currency */      nnn=GWEN_XMLNode_FindFirstTag(nn, "D_6345", 0, 0);      if (nnn) {        s=GWEN_XMLNode_GetProperty(nnn, "value", 0);        if (s)          AB_ImExporterAccountInfo_SetCurrency(ai, s);      }    }    /* account number */    s=GWEN_XMLNode_GetCharValue(n, "PF:D_5388", 0);    if (s)      AB_ImExporterAccountInfo_SetAccountName(ai, s);  }  /* owner name */  n=GWEN_XMLNode_GetNodeByXPath(doc, "SG3[1]/NAD",                                GWEN_PATH_FLAGS_NAMEMUSTEXIST);  if (n) {    GWEN_XMLNODE *nn;    nn=GWEN_XMLNode_FindFirstTag(n, "D_3035", 0, 0);    if (nn) {      const char *s;      s=GWEN_XMLNode_GetProperty(nn, "Value", 0);      if (s && strcasecmp(s, "HQ")==0) {        nn=GWEN_XMLNode_FindFirstTag(n, "C058", 0, 0);        if (nn) {          s=GWEN_XMLNode_GetCharValue(nn, "D_3124", 0);          if (s && *s) {            GWEN_BUFFER *xbuf;            xbuf=GWEN_Buffer_new(0, 256, 0, 1);            AB_ImExporter_Iso8859_1ToUtf8(s, strlen(s), xbuf);            AB_ImExporterAccountInfo_SetOwner(ai, GWEN_Buffer_GetStart(xbuf));            GWEN_Buffer_free(xbuf);          }        }      }    }  }  return ai;}

AB_TRANSACTION *AB_ImExporterYN__ReadLNE_LNS(AB_IMEXPORTER *ie,                                             AB_IMEXPORTER_ACCOUNTINFO *ai,                                             GWEN_XMLNODE *node){  AB_TRANSACTION *t;  GWEN_XMLNODE *nn;  GWEN_DATE *da=NULL;  AB_VALUE *val=NULL;  t=AB_Transaction_new();  /* get date */  nn=GWEN_XMLNode_FindFirstTag(node, "DTM", 0, 0);  if (nn)    da=AB_ImExporterYN__ReadDate(ie, nn, 209);  AB_Transaction_SetValutaDate(t, da);  GWEN_Date_free(da);  da=NULL;  /* read amount */  nn=GWEN_XMLNode_FindFirstTag(node, "MOA", 0, 0);  if (nn) {    /* Gutschrift */    val=AB_ImExporterYN__ReadValue(ie, nn, 210);    if (val) {      if (AB_Value_IsZero(val)) {        AB_Value_free(val);        val=NULL;      }    }    if (val==NULL) {      val=AB_ImExporterYN__ReadValue(ie, nn, 211);      if (val)        AB_Value_Negate(val);    }  }  if (val==NULL)    val=AB_Value_new();  AB_Value_SetCurrency(val, AB_ImExporterAccountInfo_GetCurrency(ai));  AB_Transaction_SetValue(t, val);  AB_Value_free(val);  val=0;  /* read purpose */  nn=GWEN_XMLNode_GetNodeByXPath(node, "FTX/C108",                                 GWEN_PATH_FLAGS_NAMEMUSTEXIST);  if (nn) {    GWEN_XMLNODE *nnn;    nnn=GWEN_XMLNode_FindFirstTag(nn, "D_4440", 0, 0);    while (nnn) {      GWEN_XMLNODE *nData;      nData=GWEN_XMLNode_GetFirstData(nnn);      if (nData) {        const char *s;        s=GWEN_XMLNode_GetData(nData);        if (s) {          GWEN_BUFFER *xbuf;          xbuf=GWEN_Buffer_new(0, 256, 0, 1);          AB_ImExporter_Iso8859_1ToUtf8(s, strlen(s), xbuf);          AB_Transaction_AddPurposeLine(t, GWEN_Buffer_GetStart(xbuf));          GWEN_Buffer_free(xbuf);        }      }      nnn=GWEN_XMLNode_FindNextTag(nnn, "D_4440", 0, 0);    }  }  return t;}

int EBC_Provider_XchgHpdRequest(AB_PROVIDER *pro,				GWEN_HTTP_SESSION *sess,				AB_USER *u) {  int rv;  GWEN_BUFFER *buf;  buf=GWEN_Buffer_new(0, 1024, 0, 1);  rv=EBC_Provider_XchgDownloadRequest(pro, sess, u, "HPD", buf, 0, NULL, NULL);  if (rv<0 || rv>=300) {    DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);    GWEN_Buffer_free(buf);    return rv;  }  else {    xmlDocPtr orderDoc=NULL;    xmlNodePtr root_node=NULL;    xmlNodePtr node=NULL;    xmlNodePtr nodeX=NULL;    const char *s;    uint32_t uflags=0;    /* parse XML document */    rv=EB_Xml_DocFromBuffer(GWEN_Buffer_GetStart(buf),			    GWEN_Buffer_GetUsedBytes(buf),			    &orderDoc);    GWEN_Buffer_free(buf);    if (rv<0) {      DBG_INFO(AQEBICS_LOGDOMAIN, "here (%d)", rv);      return rv;    }    /* get keys */    root_node=xmlDocGetRootElement(orderDoc);    /* get auth key */    node=EB_Xml_GetNode(root_node, "ProtocolParams",			GWEN_PATH_FLAGS_NAMEMUSTEXIST);    if (node==NULL) {      DBG_ERROR(AQEBICS_LOGDOMAIN,		"No ProtocolParams found");      xmlFreeDoc(orderDoc);      return GWEN_ERROR_BAD_DATA;    }    nodeX=EB_Xml_GetNode(node, "ClientDataDownload",			 GWEN_PATH_FLAGS_NAMEMUSTEXIST);    if (nodeX) {      s=(const char*)xmlGetProp(nodeX, BAD_CAST "supported");      if (s && strcasecmp(s, "true")==0) {        DBG_INFO(AQEBICS_LOGDOMAIN, "Client data download supported");	uflags|=EBC_USER_FLAGS_CLIENT_DATA_DOWNLOAD_SPP;      }    }    nodeX=EB_Xml_GetNode(node, "PreValidation",			 GWEN_PATH_FLAGS_NAMEMUSTEXIST);    if (nodeX) {      s=(const char*)xmlGetProp(nodeX, BAD_CAST "supported");      if (s && strcasecmp(s, "true")==0) {	DBG_INFO(AQEBICS_LOGDOMAIN, "Prevalidation supported");	uflags|=EBC_USER_FLAGS_PREVALIDATION_SPP;      }    }    nodeX=EB_Xml_GetNode(node, "Recovery",			 GWEN_PATH_FLAGS_NAMEMUSTEXIST);    if (nodeX) {      s=(const char*)xmlGetProp(nodeX, BAD_CAST "supported");      if (s && strcasecmp(s, "true")==0) {	DBG_INFO(AQEBICS_LOGDOMAIN, "Recovery supported");	uflags|=EBC_USER_FLAGS_RECOVERY_SPP;      }    }    EBC_User_AddFlags(u, uflags);    xmlFreeDoc(orderDoc);    return 0;  }}

//.........这里部分代码省略.........      "Specify the account id (Kontonummer)"     /* long description */    },    {      GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */      GWEN_ArgsType_Int,             /* type */      "help",                       /* name */      0,                            /* minnum */      0,                            /* maxnum */      "h",                          /* short option */      "help",                       /* long option */      "Show this help screen",      /* short description */      "Show this help screen"       /* long description */    }  };  db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local");  rv=GWEN_Args_Check(argc, argv, 1,                     0 /*GWEN_ARGS_MODE_ALLOW_FREEPARAM*/,                     args,                     db);  if (rv==GWEN_ARGS_RESULT_ERROR) {    fprintf(stderr, "ERROR: Could not parse arguments/n");    return 1;  }  else if (rv==GWEN_ARGS_RESULT_HELP) {    GWEN_BUFFER *ubuf;    ubuf=GWEN_Buffer_new(0, 1024, 0, 1);    if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {      fprintf(stderr, "ERROR: Could not create help string/n");      return 1;    }    fprintf(stdout, "%s/n", GWEN_Buffer_GetStart(ubuf));    GWEN_Buffer_free(ubuf);    return 0;  }  userId=GWEN_DB_GetIntValue(db, "userId", 0, 0);  if (userId<1) {    fprintf(stderr, "ERROR: Invalid user id/n");    return 1;  }  bankId=GWEN_DB_GetCharValue(db, "bankId", 0, "*");  accountId=GWEN_DB_GetCharValue(db, "accountId", 0, "*");  accountName=GWEN_DB_GetCharValue(db, "accountName", 0, "Account");  ownerName=GWEN_DB_GetCharValue(db, "ownerName", 0, NULL);  rv=AB_Provider_HasUser(pro, userId);  if (rv<0) {    fprintf(stderr, "ERROR: User with id %lu not found/n", (unsigned long int) userId);    return 2;  }  rv=AB_Provider_GetUser(pro, userId, 1, 1, &u);  if (rv<0) {    fprintf(stderr, "ERROR: User with id %lu not found/n", (unsigned long int) userId);    return 2;  }  else {    AB_ACCOUNT *account;    AB_BANKINFO_LIST2 *bl;    AB_BANKINFO_LIST2_ITERATOR *bit;    AB_BANKINFO *tbi;    AB_BANKINFO *bi;    int rv;

int GWEN_PathManager_InsertRelPath(const char *callingLib,                                   const char *destLib,                                   const char *pathName,                                   const char *pathValue,                                   GWEN_PATHMANAGER_RELMODE rm) {  char cwd[256];  switch(rm) {  case GWEN_PathManager_RelModeCwd: {    const char *pcwd;    pcwd=getcwd(cwd, sizeof(cwd)-1);    if (pcwd) {      GWEN_BUFFER *buf;      int rv;      buf=GWEN_Buffer_new(0, 256, 0, 1);      GWEN_Buffer_AppendString(buf, cwd);      if (*pathValue!=GWEN_DIR_SEPARATOR)        GWEN_Buffer_AppendString(buf, GWEN_DIR_SEPARATOR_S);      GWEN_Buffer_AppendString(buf, pathValue);      rv=GWEN_PathManager_InsertPath(callingLib, destLib, pathName,                                     GWEN_Buffer_GetStart(buf));      GWEN_Buffer_free(buf);      return rv;    }    else {      DBG_ERROR(GWEN_LOGDOMAIN, "getcwd(): %s", strerror(errno));      return GWEN_ERROR_IO;    }    break;  }  case GWEN_PathManager_RelModeExe: {    int rv;    rv=GWEN_Directory_GetPrefixDirectory(cwd, sizeof(cwd)-1);    if (rv) {      DBG_INFO(GWEN_LOGDOMAIN, "here (%d)", rv);      return rv;    }    else {      GWEN_BUFFER *buf;      buf=GWEN_Buffer_new(0, 256, 0, 1);      GWEN_Buffer_AppendString(buf, cwd);      if (*pathValue!=GWEN_DIR_SEPARATOR)        GWEN_Buffer_AppendString(buf, GWEN_DIR_SEPARATOR_S);      GWEN_Buffer_AppendString(buf, pathValue);      DBG_INFO(GWEN_LOGDOMAIN,               "Adding path [%s]",               GWEN_Buffer_GetStart(buf));      rv=GWEN_PathManager_InsertPath(callingLib, destLib, pathName,                                     GWEN_Buffer_GetStart(buf));      GWEN_Buffer_free(buf);      return rv;    }  }  case GWEN_PathManager_RelModeHome: {    GWEN_BUFFER *buf;    int rv;    rv=GWEN_Directory_GetHomeDirectory(cwd, sizeof(cwd)-1);    if (rv) {      DBG_ERROR(GWEN_LOGDOMAIN,                "Could not determine HOME directory (%d)",                rv);      return rv;    }    buf=GWEN_Buffer_new(0, 256, 0, 1);    GWEN_Buffer_AppendString(buf, cwd);    if (*pathValue!=GWEN_DIR_SEPARATOR)      GWEN_Buffer_AppendString(buf, GWEN_DIR_SEPARATOR_S);    GWEN_Buffer_AppendString(buf, pathValue);    rv=GWEN_PathManager_InsertPath(callingLib, destLib, pathName,                                   GWEN_Buffer_GetStart(buf));    GWEN_Buffer_free(buf);    return rv;  }  default:    DBG_INFO(GWEN_LOGDOMAIN, "Unknown relative mode %d", rm);    return GWEN_ERROR_INVALID;  }}

//.........这里部分代码省略.........    p=AH_User_GetSystemId(su);  if (!p)    p="0";  GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p);  if (tm) {    GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,			"function", tm);  }  /* retrieve control reference for sigtail (to be used later) */  p=GWEN_DB_GetCharValue(cfg, "ctrlref", 0, "");  if (strlen(p)>=sizeof(ctrlref)) {    DBG_INFO(AQHBCI_LOGDOMAIN,	     "Control reference too long (14 bytes maximum)");    GWEN_DB_Group_free(cfg);    return -1;  }  strcpy(ctrlref, p);  /* create SigHead */  hbuf=GWEN_Buffer_new(0, 128+GWEN_Buffer_GetUsedBytes(rawBuf), 0, 1);  GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,                      "head/seq", hmsg->firstSegment-1);  GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,		      "signseq", 1);  /* create signature head segment */  rv=GWEN_MsgEngine_CreateMessageFromNode(e, node, hbuf, cfg);  GWEN_DB_Group_free(cfg);  cfg=0;  if (rv) {    DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create SigHead");    GWEN_Buffer_free(hbuf);    return rv;  }  /* insert new SigHead at beginning of message buffer */  DBG_DEBUG(AQHBCI_LOGDOMAIN, "Inserting signature head");  GWEN_Buffer_Rewind(hmsg->buffer);  GWEN_Buffer_InsertBytes(hmsg->buffer,			  GWEN_Buffer_GetStart(hbuf),			  GWEN_Buffer_GetUsedBytes(hbuf));  /* create sigtail */  DBG_DEBUG(AQHBCI_LOGDOMAIN, "Completing signature tail");  cfg=GWEN_DB_Group_new("sigtail");  GWEN_Buffer_Reset(hbuf);  GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,                      "head/seq", hmsg->lastSegment+1);  /* store to DB */  GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,		      "signature",		      "NOSIGNATURE",                      11);  GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT,		       "ctrlref", ctrlref);  /* handle pin */  memset(pin, 0, sizeof(pin));  rv=AH_User_InputPin(su, pin, 4, sizeof(pin), 0);  if (rv<0) {    DBG_ERROR(AQHBCI_LOGDOMAIN,	      "Error getting pin from medium (%d)", rv);    GWEN_DB_Group_free(cfg);    GWEN_Buffer_free(hbuf);

//.........这里部分代码省略.........      "Import a user which has already been in use (e.g. with previous versions)"    },    {      GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */      GWEN_ArgsType_Int,            /* type */      "help",                       /* name */      0,                            /* minnum */      0,                            /* maxnum */      "h",                          /* short option */      "help",                       /* long option */      "Show this help screen",      /* short description */      "Show this help screen"       /* long description */    }  };  db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local");  rv=GWEN_Args_Check(argc, argv, 1,                     0 /*GWEN_ARGS_MODE_ALLOW_FREEPARAM*/,                     args,                     db);  if (rv==GWEN_ARGS_RESULT_ERROR) {    fprintf(stderr, "ERROR: Could not parse arguments/n");    return 1;  }  else if (rv==GWEN_ARGS_RESULT_HELP) {    GWEN_BUFFER *ubuf;    ubuf=GWEN_Buffer_new(0, 1024, 0, 1);    if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {      fprintf(stderr, "ERROR: Could not create help string/n");      return 1;    }    fprintf(stdout, "%s/n", GWEN_Buffer_GetStart(ubuf));    GWEN_Buffer_free(ubuf);    return 0;  }  tokenType=GWEN_DB_GetCharValue(db, "tokenType", 0, 0);  tokenName=GWEN_DB_GetCharValue(db, "tokenName", 0, 0);  bankId=GWEN_DB_GetCharValue(db, "bankId", 0, 0);  userId=GWEN_DB_GetCharValue(db, "userId", 0, 0);  customerId=GWEN_DB_GetCharValue(db, "customerId", 0, 0);  hostName=GWEN_DB_GetCharValue(db, "hostName", 0, 0);  userName=GWEN_DB_GetCharValue(db, "userName", 0, 0);  server=GWEN_DB_GetCharValue(db, "serverAddr", 0, 0);  cid=GWEN_DB_GetIntValue(db, "context", 0, 0);  importing=GWEN_DB_GetIntValue(db, "import", 0, 0);  ebicsVersion=GWEN_DB_GetCharValue(db, "ebicsVersion", 0, "H003");  if (1) {    const char *lbankId;    const char *luserId;    const char *lcustomerId;    const char *lserverAddr;    GWEN_URL *url;    GWEN_CRYPT_TOKEN_CONTEXT *ctx=NULL;    AB_USER *user;    if (1) {      GWEN_PLUGIN_MANAGER *pm;      GWEN_PLUGIN *pl;      GWEN_CRYPT_TOKEN *ct;      const GWEN_CRYPT_TOKEN_CONTEXT *cctx;      if (cid==0) {        DBG_ERROR(0, "No context given.");

int AH_Msg_EncryptPinTan(AH_MSG *hmsg) {  AH_HBCI *h;  GWEN_XMLNODE *node;  GWEN_DB_NODE *cfg;  GWEN_BUFFER *hbuf;  int rv;  const char *p;  GWEN_MSGENGINE *e;  AB_USER *u;  const char *peerId;//  uint32_t uFlags;  assert(hmsg);  h=AH_Dialog_GetHbci(hmsg->dialog);  assert(h);  e=AH_Dialog_GetMsgEngine(hmsg->dialog);  assert(e);  GWEN_MsgEngine_SetMode(e, "pintan");  u=AH_Dialog_GetDialogOwner(hmsg->dialog);//  uFlags=AH_User_GetFlags(u);  peerId=AH_User_GetPeerId(u);  if (!peerId || *peerId==0)    peerId=AB_User_GetUserId(u);  /* create crypt head */  node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,						    "SEG",						    "id",						    0,						    "CryptHead");  if (!node) {    DBG_INFO(AQHBCI_LOGDOMAIN, "Segment /"CryptHead/" not found");    return GWEN_ERROR_INTERNAL;  }  /* create CryptHead */  cfg=GWEN_DB_Group_new("crypthead");  GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,		      "head/seq", 998);  rv=AH_MsgPinTan_PrepareCryptoSeg(hmsg, u, cfg, 1, 0);  if (rv) {    DBG_INFO(AQHBCI_LOGDOMAIN, "here (%d)", rv);    GWEN_DB_Group_free(cfg);    return rv;  }  /* store system id */  p=NULL;  if (!hmsg->noSysId)    p=AH_User_GetSystemId(u);  if (!p)    p="0";  GWEN_DB_SetCharValue(cfg, GWEN_DB_FLAGS_DEFAULT, "SecDetails/SecId", p);  /* store encrypted message key */  GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,		      "CryptAlgo/MsgKey",                      "NOKEY", 5);  hbuf=GWEN_Buffer_new(0, 256+GWEN_Buffer_GetUsedBytes(hmsg->buffer), 0, 1);  rv=GWEN_MsgEngine_CreateMessageFromNode(e,					  node,					  hbuf,					  cfg);  if (rv) {    DBG_INFO(AQHBCI_LOGDOMAIN, "Could not create CryptHead (%d)", rv);    GWEN_Buffer_free(hbuf);    GWEN_DB_Group_free(cfg);    return rv;  }  GWEN_DB_Group_free(cfg);  /* create cryptdata */  cfg=GWEN_DB_Group_new("cryptdata");  GWEN_DB_SetIntValue(cfg, GWEN_DB_FLAGS_DEFAULT,                      "head/seq", 999);  GWEN_DB_SetBinValue(cfg, GWEN_DB_FLAGS_DEFAULT,		      "cryptdata",		      GWEN_Buffer_GetStart(hmsg->buffer),                      GWEN_Buffer_GetUsedBytes(hmsg->buffer));  node=GWEN_MsgEngine_FindNodeByPropertyStrictProto(e,						    "SEG",						    "id",						    0,						    "CryptData");  if (!node) {    DBG_INFO(AQHBCI_LOGDOMAIN, "Segment /"CryptData/"not found");    GWEN_Buffer_free(hbuf);    GWEN_DB_Group_free(cfg);    return -1;  }  rv=GWEN_MsgEngine_CreateMessageFromNode(e,                                          node,                                          hbuf,                                          cfg);  if (rv) {//.........这里部分代码省略.........

int listAccounts(AB_BANKING *ab,                 GWEN_DB_NODE *dbArgs,                 int argc,                 char **argv) {  GWEN_DB_NODE *db;  int rv;  AB_ACCOUNT_LIST2 *al;  const GWEN_ARGS args[]={  {    GWEN_ARGS_FLAGS_HELP | GWEN_ARGS_FLAGS_LAST, /* flags */    GWEN_ArgsType_Int,            /* type */    "help",                       /* name */    0,                            /* minnum */    0,                            /* maxnum */    "h",                          /* short option */    "help",                       /* long option */    "Show this help screen",      /* short description */    "Show this help screen"       /* long description */  }  };  db=GWEN_DB_GetGroup(dbArgs, GWEN_DB_FLAGS_DEFAULT, "local");  rv=GWEN_Args_Check(argc, argv, 1,                     0 /*GWEN_ARGS_MODE_ALLOW_FREEPARAM*/,                     args,                     db);  if (rv==GWEN_ARGS_RESULT_ERROR) {    fprintf(stderr, "ERROR: Could not parse arguments/n");    return 1;  }  else if (rv==GWEN_ARGS_RESULT_HELP) {    GWEN_BUFFER *ubuf;    ubuf=GWEN_Buffer_new(0, 1024, 0, 1);    if (GWEN_Args_Usage(args, ubuf, GWEN_ArgsOutType_Txt)) {      fprintf(stderr, "ERROR: Could not create help string/n");      return 1;    }    fprintf(stderr, "%s/n", GWEN_Buffer_GetStart(ubuf));    GWEN_Buffer_free(ubuf);    return 0;  }  rv=AB_Banking_Init(ab);  if (rv) {    DBG_ERROR(0, "Error on init (%d)", rv);    return 2;  }  rv=AB_Banking_OnlineInit(ab);  if (rv) {    DBG_ERROR(0, "Error on init (%d)", rv);    return 2;  }  al=AB_Banking_FindAccounts(ab, EBC_PROVIDER_NAME, "*", "*", "*", "*");  if (al) {    AB_ACCOUNT_LIST2_ITERATOR *ait;    ait=AB_Account_List2_First(al);    if (ait) {      AB_ACCOUNT *a;      int i=0;      a=AB_Account_List2Iterator_Data(ait);      assert(a);      while(a) {        fprintf(stdout, "Account %d: Bank: %s Account Number: %s/n",                i++,                AB_Account_GetBankCode(a),                AB_Account_GetAccountNumber(a));        a=AB_Account_List2Iterator_Next(ait);      }      AB_Account_List2Iterator_free(ait);    }    AB_Account_List2_free(al);  }  rv=AB_Banking_OnlineFini(ab);  if (rv) {    fprintf(stderr, "ERROR: Error on deinit (%d)/n", rv);    return 5;  }  rv=AB_Banking_Fini(ab);  if (rv) {    fprintf(stderr, "ERROR: Error on deinit (%d)/n", rv);    return 5;  }  return 0;}

int AH_Msg_DecryptPinTan(AH_MSG *hmsg, GWEN_DB_NODE *gr){  AH_HBCI *h;  GWEN_BUFFER *mbuf;  uint32_t l;  const uint8_t *p;  GWEN_MSGENGINE *e;  AB_USER *u;  const char *peerId;//  uint32_t uFlags;  GWEN_DB_NODE *nhead=NULL;  GWEN_DB_NODE *ndata=NULL;  const char *crypterId;  assert(hmsg);  h=AH_Dialog_GetHbci(hmsg->dialog);  assert(h);  e=AH_Dialog_GetMsgEngine(hmsg->dialog);  assert(e);  GWEN_MsgEngine_SetMode(e, "pintan");  u=AH_Dialog_GetDialogOwner(hmsg->dialog);//  uFlags=AH_User_GetFlags(u);  peerId=AH_User_GetPeerId(u);  if (!peerId || *peerId==0)    peerId=AB_User_GetUserId(u);  /* get encrypted session key */  nhead=GWEN_DB_GetGroup(gr,			 GWEN_DB_FLAGS_DEFAULT |			 GWEN_PATH_FLAGS_NAMEMUSTEXIST,			 "CryptHead");  if (!nhead) {    DBG_ERROR(AQHBCI_LOGDOMAIN, "No crypt head");    return GWEN_ERROR_BAD_DATA;  }  ndata=GWEN_DB_GetGroup(gr,                         GWEN_DB_FLAGS_DEFAULT |                         GWEN_PATH_FLAGS_NAMEMUSTEXIST,                         "CryptData");  if (!ndata) {    DBG_ERROR(AQHBCI_LOGDOMAIN, "No crypt data");    return GWEN_ERROR_BAD_DATA;  }  crypterId=GWEN_DB_GetCharValue(nhead, "key/userId", 0, I18N("unknown"));  /* get encrypted data */  p=GWEN_DB_GetBinValue(ndata,			"CryptData",                        0,                        0,0,			&l);  if (!p || !l) {    DBG_ERROR(AQHBCI_LOGDOMAIN, "No crypt data");    return GWEN_ERROR_BAD_DATA;  }  /* decipher message with session key */  mbuf=GWEN_Buffer_new(0, l, 0, 1);  GWEN_Buffer_AppendBytes(mbuf, (const char*)p, l);  /* store crypter id */  AH_Msg_SetCrypterId(hmsg, crypterId);  /* store new buffer inside message */  GWEN_Buffer_free(hmsg->origbuffer);  hmsg->origbuffer=hmsg->buffer;  GWEN_Buffer_Rewind(mbuf);  hmsg->buffer=mbuf;  return 0;}