Examples of HBCIMsgStatus


Examples of org.kapott.hbci.status.HBCIMsgStatus

        a new rawMsg in the kernel and processes it. The return values will be
        passed to appropriate methods in the @c institute and @c user objects to
        update their internal state with the data received from the institute. */
    private HBCIMsgStatus doDialogInit()
    {
        HBCIMsgStatus ret=new HBCIMsgStatus();
       
        try {
            HBCIPassportInternal mainPassport=(HBCIPassportInternal)getParentHandler().getPassport();
            HBCIKernelImpl       kernel=(HBCIKernelImpl)getParentHandler().getKernel();
           
            // autosecmech
            HBCIUtils.log("checking whether passport is supported (but ignoring result)",HBCIUtils.LOG_DEBUG);
            boolean s=mainPassport.isSupported();
            HBCIUtils.log("passport supported: "+s,HBCIUtils.LOG_DEBUG);
           
            HBCIUtils.log("processing dialog init",HBCIUtils.LOG_INFO);
            HBCIUtilsInternal.getCallback().status(mainPassport,HBCICallback.STATUS_DIALOG_INIT,null);
            String country=mainPassport.getCountry();
            String blz=mainPassport.getBLZ();
   
            boolean restarted=false;
            while (true) {
                kernel.rawNewMsg("DialogInit"+anonSuffix);
                kernel.rawSet("Idn.KIK.blz", blz);
                kernel.rawSet("Idn.KIK.country", country);
                if (!isAnon) {
                    kernel.rawSet("Idn.customerid", mainPassport.getCustomerId());
                    kernel.rawSet("Idn.sysid", mainPassport.getSysId());
                    String sysstatus=mainPassport.getSysStatus();
                    kernel.rawSet("Idn.sysStatus",sysstatus);
                    if (mainPassport.needInstKeys()) {
                        kernel.rawSet("KeyReq.SecProfile.method",mainPassport.getProfileMethod());
                        kernel.rawSet("KeyReq.SecProfile.version",mainPassport.getProfileVersion());
                        kernel.rawSet("KeyReq.KeyName.keytype", "V");
                        kernel.rawSet("KeyReq.KeyName.KIK.country", country);
                        kernel.rawSet("KeyReq.KeyName.KIK.blz", blz);
                        kernel.rawSet("KeyReq.KeyName.userid", mainPassport.getInstEncKeyName());
                        kernel.rawSet("KeyReq.KeyName.keynum", mainPassport.getInstEncKeyNum());
                        kernel.rawSet("KeyReq.KeyName.keyversion", mainPassport.getInstEncKeyVersion());

                        if (mainPassport.hasInstSigKey()) {
                            kernel.rawSet("KeyReq_2.SecProfile.method",mainPassport.getProfileMethod());
                            kernel.rawSet("KeyReq_2.SecProfile.version",mainPassport.getProfileVersion());
                            kernel.rawSet("KeyReq_2.KeyName.keytype", "S");
                            kernel.rawSet("KeyReq_2.KeyName.KIK.country", country);
                            kernel.rawSet("KeyReq_2.KeyName.KIK.blz", blz);
                            kernel.rawSet("KeyReq_2.KeyName.userid", mainPassport.getInstSigKeyName());
                            kernel.rawSet("KeyReq_2.KeyName.keynum", mainPassport.getInstSigKeyNum());
                            kernel.rawSet("KeyReq_2.KeyName.keyversion", mainPassport.getInstSigKeyVersion());
                        }
                    }
                }
                kernel.rawSet("ProcPrep.BPD", mainPassport.getBPDVersion());
                kernel.rawSet("ProcPrep.UPD", mainPassport.getUPDVersion());
                kernel.rawSet("ProcPrep.lang",mainPassport.getDefaultLang());
                kernel.rawSet("ProcPrep.prodName",HBCIUtils.getParam("client.product.name","HBCI4Java"));
                kernel.rawSet("ProcPrep.prodVersion",HBCIUtils.getParam("client.product.version","2.5"));
                ret=kernel.rawDoIt(!isAnon && HBCIKernelImpl.SIGNIT,
                        !isAnon && HBCIKernelImpl.CRYPTIT,
                        !isAnon && HBCIKernelImpl.NEED_SIG,
                        !isAnon && HBCIKernelImpl.NEED_CRYPT);

                boolean need_restart=mainPassport.postInitResponseHook(ret,isAnon);
                if (need_restart) {
                    HBCIUtils.log("for some reason we have to restart this dialog", HBCIUtils.LOG_INFO);
                    if (restarted) {
                        HBCIUtils.log("this dialog already has been restarted once - to avoid endless loops we stop here", HBCIUtils.LOG_WARN);
                        throw new HBCI_Exception("*** restart loop - aborting");
                    }
                    restarted=true;
                } else {
                    break;
                }
            }
           
            Properties result=ret.getData();
            if (ret.isOK()) {
                HBCIInstitute inst=new HBCIInstitute(kernel,mainPassport,false);
                inst.updateBPD(result);
                inst.extractKeys(result);
   
                HBCIUser user=new HBCIUser(kernel,mainPassport,false);
                user.updateUPD(result);
              
                mainPassport.saveChanges();
   
                msgnum=2;
                dialogid=result.getProperty("MsgHead.dialogid");
                HBCIUtils.log("dialog-id set to "+dialogid,HBCIUtils.LOG_DEBUG);

                HBCIInstMessage msg=null;
                for (int i=0;true;i++) {
                    try {
                        String header=HBCIUtilsInternal.withCounter("KIMsg",i);
                        msg=new HBCIInstMessage(result,header);
                    } catch (Exception e) {
                        break;
                    }
                    HBCIUtilsInternal.getCallback().callback(mainPassport,
                                                     HBCICallback.HAVE_INST_MSG,
                                                     msg.toString(),
                                                     HBCICallback.TYPE_NONE,
                                                     new StringBuffer());
                }
            }

            HBCIUtilsInternal.getCallback().status(mainPassport,HBCICallback.STATUS_DIALOG_INIT_DONE,new Object[] {ret,dialogid});
        } catch (Exception e) {
            ret.addException(e);
        }

        return ret;
    }
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

           
            // loop wird benutzt, um zu z�hlen, wie oft bereits "nachgehakt" wurde,
            // falls ein bestimmter job nicht mit einem einzigen nachrichtenaustausch
            // abgearbeitet werden konnte (z.b. abholen kontoausz�ge)
            int           loop=0;
            HBCIMsgStatus msgstatus=new HBCIMsgStatus();
           
            // diese schleife loopt solange, bis alle jobs der aktuellen nachricht
            // tats�chlich abgearbeitet wurden (also inclusive "nachhaken")
            while (true) {
                boolean addMsgStatus=true;
               
                try {
                    HBCIUtils.log("generating custom msg #"+(j+1)+" (loop "+(loop+1)+")",
                        HBCIUtils.LOG_DEBUG);
                   
                    int taskNum=0;

                    msgPassports.clear();
                    kernel.rawNewMsg("CustomMsg");
                   
                    // durch alle jobs loopen, die eigentlich in der aktuellen
                    // nachricht abgearbeitet werden m�ssten
                    for (Iterator<HBCIJobImpl> i=tasks.iterator();i.hasNext();) {
                        HBCIJobImpl task=i.next();
                       
                        // wenn der Task entweder noch gar nicht ausgef�hrt wurde
                        // oder in der letzten Antwortnachricht ein entsprechendes
                        // Offset angegeben wurde
                        if (task.needsContinue(loop)) {
                            task.setContinueOffset(loop);
                           
                            Properties p=task.getLowlevelParams();
                            String header=HBCIUtilsInternal.withCounter("GV",taskNum);
                           
                            String taskName=task.getName();
                            HBCIUtils.log("adding task "+taskName,HBCIUtils.LOG_DEBUG);
                            HBCIUtilsInternal.getCallback().status(mainPassport,HBCICallback.STATUS_SEND_TASK,task);
                            task.setIdx(taskNum);
                           
                            // Daten f�r den Task festlegen
                            for (Enumeration e=p.keys();e.hasMoreElements();) {
                                String key=(String)(e.nextElement());
                                kernel.rawSet(header+"."+key,p.getProperty(key));
                            }
                           
                            // additional passports f�r diesen task ermitteln
                            // und zu den passports f�r die aktuelle nachricht
                            // hinzuf�gen;
                            // doppelg�nger werden schon von
                            // HBCIPassportList.addPassport() herausgefiltert
                            msgPassports.addAll(task.getSignaturePassports());
                           
                            taskNum++;
                        }
                    }
                   
                    // wenn keine jobs f�r die aktuelle message existieren
                    if (taskNum==0) {
                        HBCIUtils.log(
                                "loop "+(loop+1)+" aborted, because there are no more tasks to be executed",
                                HBCIUtils.LOG_DEBUG);
                        addMsgStatus=false;
                        break;
                    }
                   
                    kernel.rawSet("MsgHead.dialogid", dialogid);
                    kernel.rawSet("MsgHead.msgnum", getMsgNum());
                    kernel.rawSet("MsgTail.msgnum", getMsgNum());
                    nextMsgNum();
                   
                    // nachrichtenaustausch durchf�hren
                    msgstatus=kernel.rawDoIt(msgPassports,HBCIKernelImpl.SIGNIT,HBCIKernelImpl.CRYPTIT,HBCIKernelImpl.NEED_SIG,HBCIKernelImpl.NEED_CRYPT);
                    Properties result=msgstatus.getData();
                   
                    // searching for first segment number that belongs to the custom_msg
                    // we look for entries like {"1","CustomMsg.MsgHead"} and so
                    // on (this data is inserted from the HBCIKernelImpl.rawDoIt() method),
                    // until we find the first segment containing a task
                    int offset=0;   // this specifies, how many segments precede the first task segment
                    for (offset=1;true;offset++) {
                        String path=result.getProperty(Integer.toString(offset));
                        if (path==null || path.startsWith("CustomMsg.GV")) {
                            if (path==null) { // wenn kein entsprechendes Segment gefunden, dann offset auf 0 setzen
                                offset=0;
                            }
                            break;
                        }
                    }
                   
                    if (offset!=0) {          
                        // f�r jeden Task die entsprechenden R�ckgabedaten-Klassen f�llen
                        // in fillOutStore wird auch "executed" fuer den jeweiligen Task auf true gesetzt.
                        for (Iterator<HBCIJobImpl> i=tasks.iterator();i.hasNext();) {
                            HBCIJobImpl task=i.next();
                            if (task.needsContinue(loop)) {
                                // nur wenn der auftrag auch tatsaechlich gesendet werden musste
                                try {
                                    task.fillJobResult(msgstatus,offset);
                                    HBCIUtilsInternal.getCallback().status(mainPassport,HBCICallback.STATUS_SEND_TASK_DONE,task);
                                } catch (Exception e) {
                                    msgstatus.addException(e);
                                }
                            }
                        }
                    }
                   
                    if (msgstatus.hasExceptions()) {
                        HBCIUtils.log("aborting current loop because of errors",HBCIUtils.LOG_ERR);
                        break;
                    }
                   
                    loop++;
                } catch (Exception e) {
                    msgstatus.addException(e);
                } finally {
                    if (addMsgStatus) {
                        msgstatus_a.add(msgstatus);
                    }
                }
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

    /** @brief Processes the DialogEnd stage of an HBCIDialog (mid-level API).

        Works similarily to doDialogInit(). */
    private HBCIMsgStatus doDialogEnd()
    {
        HBCIMsgStatus ret=new HBCIMsgStatus();
       
        HBCIHandler          handler=getParentHandler();
        HBCIPassportInternal mainPassport=(HBCIPassportInternal)handler.getPassport();
        HBCIKernelImpl       kernel=(HBCIKernelImpl)handler.getKernel();
       
        try {
            HBCIUtils.log("processing dialog end",HBCIUtils.LOG_INFO);
            HBCIUtilsInternal.getCallback().status(mainPassport,HBCICallback.STATUS_DIALOG_END,null);
   
            kernel.rawNewMsg("DialogEnd"+anonSuffix);
            kernel.rawSet("DialogEndS.dialogid", dialogid);
            kernel.rawSet("MsgHead.dialogid", dialogid);
            kernel.rawSet("MsgHead.msgnum", getMsgNum());
            kernel.rawSet("MsgTail.msgnum", getMsgNum());
            nextMsgNum();
            ret=kernel.rawDoIt(!isAnon && HBCIKernelImpl.SIGNIT,
                               !isAnon && HBCIKernelImpl.CRYPTIT,
                               !isAnon && HBCIKernelImpl.NEED_SIG,
                               !isAnon && HBCIKernelImpl.NEED_CRYPT);

            HBCIUtilsInternal.getCallback().status(mainPassport,HBCICallback.STATUS_DIALOG_END_DONE,ret);
        } catch (Exception e) {
            ret.addException(e);
        }

        return ret;
    }
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

            HBCIPassportInternal passport=(HBCIPassportInternal)getParentHandler().getPassport();
           
            // first call passports's before-dialog-hook
            passport.beforeCustomDialogHook(this);
           
            HBCIMsgStatus initStatus=doDialogInit();
            ret.setInitStatus(initStatus);
               
            // so that e.g. pintan-passports can patch the list of messages to
            // be executed (needed for twostep-mech)
            passport.afterCustomDialogInitHook(this);
           
            if (initStatus.isOK()) {
                ret.setMsgStatus(doJobs());
                ret.setEndStatus(doDialogEnd());
            }
           
            return ret;
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

        kernel.rawNewMsg("DialogEndAnon");
        kernel.rawSet("MsgHead.dialogid",dialogid);
        kernel.rawSet("MsgHead.msgnum","2");
        kernel.rawSet("DialogEndS.dialogid",dialogid);
        kernel.rawSet("MsgTail.msgnum","2");
        HBCIMsgStatus status=kernel.rawDoIt(HBCIKernelImpl.DONT_SIGNIT,HBCIKernelImpl.DONT_CRYPTIT,needSig,HBCIKernelImpl.DONT_NEED_CRYPT);
        HBCIUtilsInternal.getCallback().status(passport,HBCICallback.STATUS_DIALOG_END_DONE,status);
       
        if (!status.isOK()) {
            HBCIUtils.log("dialog end failed: "+status.getErrorString(),HBCIUtils.LOG_ERR);
           
            String msg=HBCIUtilsInternal.getLocMsg("ERR_INST_ENDFAILED");
            if (!HBCIUtilsInternal.ignoreError(null,"client.errors.ignoreDialogEndErrors",
                                       msg+": "+status.getErrorString())) {
                throw new ProcessException(msg,status);
            }
        }
    }
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

                }
               
                HBCIUtilsInternal.getCallback().status(passport,HBCICallback.STATUS_INST_BPD_INIT,null);
                HBCIUtils.log("fetching BPD",HBCIUtils.LOG_INFO);
               
                HBCIMsgStatus status=null;
                boolean       restarted=false;
                while (true) {
                    kernel.rawNewMsg("DialogInitAnon");
                    kernel.rawSet("Idn.KIK.blz", passport.getBLZ());
                    kernel.rawSet("Idn.KIK.country", passport.getCountry());
                    kernel.rawSet("ProcPrep.BPD", "0");
                    kernel.rawSet("ProcPrep.UPD", passport.getUPDVersion());
                    kernel.rawSet("ProcPrep.lang", "0");
                    kernel.rawSet("ProcPrep.prodName", HBCIUtils.getParam("client.product.name","HBCI4Java"));
                    kernel.rawSet("ProcPrep.prodVersion", HBCIUtils.getParam("client.product.version","2.5"));

                    status=kernel.rawDoIt(HBCIKernelImpl.DONT_SIGNIT,HBCIKernelImpl.DONT_CRYPTIT,
                            HBCIKernelImpl.DONT_NEED_SIG,HBCIKernelImpl.DONT_NEED_CRYPT);

                    boolean need_restart=passport.postInitResponseHook(status, true);
                    if (need_restart) {
                        HBCIUtils.log("for some reason we have to restart this dialog", HBCIUtils.LOG_INFO);
                        if (restarted) {
                            HBCIUtils.log("this dialog already has been restarted once - to avoid endless loops we stop here", HBCIUtils.LOG_WARN);
                            throw new HBCI_Exception("*** restart loop - aborting");
                        }
                        restarted=true;
                    } else {
                        break;
                    }
                }

                Properties result=status.getData();
                updateBPD(result);
                passport.saveChanges();
               
                try {
                    doDialogEnd(result.getProperty("MsgHead.dialogid"),HBCIKernelImpl.DONT_NEED_SIG);
                } catch (Exception ex) {
                    HBCIUtils.log(ex);
                }
               
                if (!status.isOK()) {
                    HBCIUtils.log("fetching BPD failed: "+status.getErrorString(),HBCIUtils.LOG_ERR);
                    throw new ProcessException(HBCIUtilsInternal.getLocMsg("ERR_INST_BPDFAILED"),status);
                }
            } catch (Exception e) {
                if (e instanceof HBCI_Exception)
                {
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

                HBCIUtils.log("fetching institute keys",HBCIUtils.LOG_INFO);
               
                String country=passport.getCountry();
                String blz=passport.getBLZ();
   
                HBCIMsgStatus status=null;
                boolean       restarted=false;
                while (true) {
                    kernel.rawNewMsg("FirstKeyReq");
                    kernel.rawSet("Idn.KIK.blz", blz);
                    kernel.rawSet("Idn.KIK.country", country);
                    kernel.rawSet("KeyReq.SecProfile.method",passport.getProfileMethod());
                    kernel.rawSet("KeyReq.SecProfile.version",passport.getProfileVersion());
                    kernel.rawSet("KeyReq.KeyName.keytype", "V");
                    kernel.rawSet("KeyReq.KeyName.KIK.blz", blz);
                    kernel.rawSet("KeyReq.KeyName.KIK.country", country);
                    kernel.rawSet("KeyReq_2.SecProfile.method",passport.getProfileMethod());
                    kernel.rawSet("KeyReq_2.SecProfile.version",passport.getProfileVersion());
                    kernel.rawSet("KeyReq_2.KeyName.keytype", "S");
                    kernel.rawSet("KeyReq_2.KeyName.KIK.blz", blz);
                    kernel.rawSet("KeyReq_2.KeyName.KIK.country", country);
                    kernel.rawSet("ProcPrep.BPD", passport.getBPDVersion());
                    kernel.rawSet("ProcPrep.UPD", passport.getUPDVersion());
                    kernel.rawSet("ProcPrep.lang", "0");
                    kernel.rawSet("ProcPrep.prodName", HBCIUtils.getParam("client.product.name","HBCI4Java"));
                    kernel.rawSet("ProcPrep.prodVersion", HBCIUtils.getParam("client.product.version","2.5"));

                    status = kernel.rawDoIt(HBCIKernelImpl.DONT_SIGNIT,HBCIKernelImpl.DONT_CRYPTIT,
                            HBCIKernelImpl.DONT_NEED_SIG,HBCIKernelImpl.DONT_NEED_CRYPT);

                    boolean need_restart=passport.postInitResponseHook(status, true);
                    if (need_restart) {
                        HBCIUtils.log("for some reason we have to restart this dialog", HBCIUtils.LOG_INFO);
                        if (restarted) {
                            HBCIUtils.log("this dialog already has been restarted once - to avoid endless loops we stop here", HBCIUtils.LOG_WARN);
                            throw new HBCI_Exception("*** restart loop - aborting");
                        }
                        restarted=true;
                    } else {
                        break;
                    }
                }

                Properties result=status.getData();
                updateBPD(result);
                extractKeys(result);
                passport.saveChanges();
               
                try {
                    doDialogEnd(result.getProperty("MsgHead.dialogid"),HBCIKernelImpl.DONT_NEED_SIG);
                } catch (Exception ex) {
                    HBCIUtils.log(ex);
                }
               
                if (!status.isOK()) {
                    HBCIUtils.log("fetching institute keys failed: "+status.getErrorString(),HBCIUtils.LOG_ERR);
                    throw new ProcessException(HBCIUtilsInternal.getLocMsg("ERR_INST_GETKEYSFAILED"),status);
                }
            } catch (Exception e) {
                throw new HBCI_Exception(HBCIUtilsInternal.getLocMsg("EXCMSG_FETCH_IKEYS_ERR"),e);
            } finally {
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

        kernel.rawNewMsg("DialogEnd"+anonSuffix);
        kernel.rawSet("MsgHead.dialogid",dialogid);
        kernel.rawSet("MsgHead.msgnum",msgnum);
        kernel.rawSet("DialogEndS.dialogid",dialogid);
        kernel.rawSet("MsgTail.msgnum",msgnum);
        HBCIMsgStatus status=kernel.rawDoIt(!isAnon && signIt,
                                            !isAnon && cryptIt,
                                            !isAnon && HBCIKernelImpl.NEED_SIG,
                                            !isAnon && needCrypt);
        HBCIUtilsInternal.getCallback().status(passport,HBCICallback.STATUS_DIALOG_END_DONE,status);

        if (!status.isOK()) {
            HBCIUtils.log("dialog end failed: "+status.getErrorString(),HBCIUtils.LOG_ERR);
           
            String msg=HBCIUtilsInternal.getLocMsg("ERR_INST_ENDFAILED");
            if (!HBCIUtilsInternal.ignoreError(null,"client.errors.ignoreDialogEndErrors",msg+": "+status.getErrorString()))
                throw new ProcessException(msg,status);
        }
    }
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

                passport.setMyPublicEncKey(encKey[0]);
                passport.setMyPrivateEncKey(encKey[1]);
                // TODO: setMyDigKey
                passport.saveChanges();
       
                HBCIMsgStatus ret=kernel.rawDoIt(HBCIKernelImpl.SIGNIT,HBCIKernelImpl.CRYPTIT,
                                                 HBCIKernelImpl.NEED_SIG,HBCIKernelImpl.DONT_NEED_CRYPT);
               
                passport.postInitResponseHook(ret, passport.isAnonymous());
                Properties result=ret.getData();
               
                HBCIUtilsInternal.getCallback().status(passport,HBCICallback.STATUS_SEND_KEYS_DONE,ret);

                if (!ret.isOK()) {
                    if (!ret.hasExceptions()) {
                        HBCIUtils.log("deleting locally generated user keys",HBCIUtils.LOG_WARN);
                        passport.clearMySigKey();
                        passport.clearMyEncKey();
                        passport.clearMyDigKey();
                        passport.saveChanges();
                    } else {
                        HBCIUtils.log("keys have not been thrown away",HBCIUtils.LOG_WARN);
                    }
       
                    throw new ProcessException(HBCIUtilsInternal.getLocMsg("EXCMSG_SENDKEYERR"),ret);
                }
       
                try {
                    doDialogEnd(result.getProperty("MsgHead.dialogid"),"2",HBCIKernelImpl.DONT_SIGNIT,HBCIKernelImpl.CRYPTIT,
                                HBCIKernelImpl.DONT_NEED_CRYPT);
                } catch (Exception e) {
                    HBCIUtils.log(e);
                }
                triggerNewKeysEvent();
            } else {
                // aendern der aktuellen Nutzerschluessel
               
                HBCIUtilsInternal.getCallback().status(passport,HBCICallback.STATUS_DIALOG_INIT,null);

                // als erstes Dialog-Initialisierung
                HBCIMsgStatus ret=null;
                boolean       restarted=false;
                while (true) {
                    kernel.rawNewMsg("DialogInit");
                    kernel.rawSet("Idn.KIK.blz", blz);
                    kernel.rawSet("Idn.KIK.country", country);
                    kernel.rawSet("Idn.customerid", passport.getCustomerId());
                    kernel.rawSet("Idn.sysid", passport.getSysId());
                    String sysstatus=passport.getSysStatus();
                    kernel.rawSet("Idn.sysStatus",sysstatus);
                    kernel.rawSet("ProcPrep.BPD",passport.getBPDVersion());
                    kernel.rawSet("ProcPrep.UPD",passport.getUPDVersion());
                    kernel.rawSet("ProcPrep.lang",passport.getLang());
                    kernel.rawSet("ProcPrep.prodName",HBCIUtils.getParam("client.product.name","HBCI4Java"));
                    kernel.rawSet("ProcPrep.prodVersion",HBCIUtils.getParam("client.product.version","2.5"));
                    ret=kernel.rawDoIt(HBCIKernelImpl.SIGNIT,HBCIKernelImpl.CRYPTIT,
                            HBCIKernelImpl.NEED_SIG,HBCIKernelImpl.NEED_CRYPT);

                    boolean need_restart=passport.postInitResponseHook(ret, passport.isAnonymous());
                    if (need_restart) {
                        HBCIUtils.log("for some reason we have to restart this dialog", HBCIUtils.LOG_INFO);
                        if (restarted) {
                            HBCIUtils.log("this dialog already has been restarted once - to avoid endless loops we stop here", HBCIUtils.LOG_WARN);
                            throw new HBCI_Exception("*** restart loop - aborting");
                        }
                        restarted=true;
                    } else {
                        break;
                    }
                }
               
                Properties result=ret.getData();
               
                if (!ret.isOK())
                    throw new ProcessException(HBCIUtilsInternal.getLocMsg("EXCMSG_GETUPDFAIL"),ret);
   
                // evtl. Passport-Daten aktualisieren
                HBCIInstitute inst=new HBCIInstitute(kernel,passport,false);
                inst.updateBPD(result);
                updateUPD(result);
                passport.saveChanges();
                HBCIUtilsInternal.getCallback().status(passport,HBCICallback.STATUS_DIALOG_INIT_DONE,new Object[] {ret,result.getProperty("MsgHead.dialogid")});

                // neue Schl�ssel senden
                HBCIUtilsInternal.getCallback().status(passport,HBCICallback.STATUS_SEND_KEYS,null);
                kernel.rawNewMsg("ChangeKeys");
                kernel.rawSet("MsgHead.dialogid",result.getProperty("MsgHead.dialogid"));
                kernel.rawSet("MsgHead.msgnum","2");
                kernel.rawSet("MsgTail.msgnum","2");
               
                kernel.rawSet("KeyChange.KeyName.KIK.blz", blz);
                kernel.rawSet("KeyChange.KeyName.KIK.country", country);
                kernel.rawSet("KeyChange.KeyName.userid", passport.getUserId());
                kernel.rawSet("KeyChange.KeyName.keynum", sigKey[0].num);
                kernel.rawSet("KeyChange.KeyName.keytype", "S"); // TODO: keytype "D"
                kernel.rawSet("KeyChange.KeyName.keyversion", sigKey[0].version);
                kernel.rawSet("KeyChange.SecProfile.method", passport.getProfileMethod());
                kernel.rawSet("KeyChange.SecProfile.version", passport.getProfileVersion());
                kernel.rawSet("KeyChange.PubKey.mode", "16"); // TODO: later real mode
                kernel.rawSet("KeyChange.PubKey.exponent", "B" + exponent[0]);
                kernel.rawSet("KeyChange.PubKey.modulus", "B" + modulus[0]);
                kernel.rawSet("KeyChange.PubKey.usage", "6");
       
                kernel.rawSet("KeyChange_2.KeyName.KIK.blz", blz);
                kernel.rawSet("KeyChange_2.KeyName.KIK.country", country);
                kernel.rawSet("KeyChange_2.KeyName.userid", passport.getUserId());
                kernel.rawSet("KeyChange_2.KeyName.keynum", encKey[0].num);
                kernel.rawSet("KeyChange_2.KeyName.keytype", "V");
                kernel.rawSet("KeyChange_2.KeyName.keyversion", encKey[0].version);
                kernel.rawSet("KeyChange_2.SecProfile.method", passport.getProfileMethod());
                kernel.rawSet("KeyChange_2.SecProfile.version", passport.getProfileVersion());
                kernel.rawSet("KeyChange_2.PubKey.mode", "16"); // TODO: later real mode
                kernel.rawSet("KeyChange_2.PubKey.exponent", "B" + exponent[1]);
                kernel.rawSet("KeyChange_2.PubKey.modulus", "B" + modulus[1]);
                kernel.rawSet("KeyChange_2.PubKey.usage", "5");
               
                // TODO: KeyChange_3
               
                HBCIKey[] oldEncKeys=new HBCIKey[2];
                oldEncKeys[0]=passport.getMyPublicEncKey();
                oldEncKeys[1]=passport.getMyPrivateEncKey();
               
                passport.setMyPublicEncKey(encKey[0]);
                passport.setMyPrivateEncKey(encKey[1]);
                passport.saveChanges();
               
                ret=kernel.rawDoIt(HBCIKernelImpl.SIGNIT,HBCIKernelImpl.CRYPTIT,
                                   HBCIKernelImpl.NEED_SIG,HBCIKernelImpl.NEED_CRYPT);
                if (!ret.isOK()) {
                    // TODO: hier muessen am besten beide schluessel im passport
                    // gesichert werden, damit spaeter ueberprueft werden
                    // kann, welcher der beiden denn nun beim server
                    // gespeichert ist. das ist dann kritisch, wenn eine
                    // eingereichte schl�ssel�nderung vom server nicht
                    // ausgef�hrt wird: dann tritt hier eine exception auf,
                    // aber es sind noch die alten schl�ssel aktiv
                    if (!ret.hasExceptions()) {
                        HBCIUtils.log("deleting locally generated user keys",HBCIUtils.LOG_WARN);
                        passport.setMyPublicEncKey(oldEncKeys[0]);
                        passport.setMyPrivateEncKey(oldEncKeys[1]);
                        passport.saveChanges();
                    } else {
                        HBCIUtils.log("keys have not been thrown away",HBCIUtils.LOG_WARN);
                    }
       
                    throw new ProcessException(HBCIUtilsInternal.getLocMsg("EXCMSG_SENDKEYERR"),ret);
                }
       
                passport.setSigId(new Long(1));
                passport.setMyPublicSigKey(sigKey[0]);
                passport.setMyPrivateSigKey(sigKey[1]);
                // TODO: setDigKey()
                passport.saveChanges();
       
                result=ret.getData();
                HBCIUtilsInternal.getCallback().status(passport,HBCICallback.STATUS_SEND_KEYS_DONE,ret);
                doDialogEnd(result.getProperty("MsgHead.dialogid"),"3",HBCIKernelImpl.SIGNIT,HBCIKernelImpl.CRYPTIT,
                                                                       HBCIKernelImpl.NEED_CRYPT);
            }
        } catch (Exception e) {
View Full Code Here

Examples of org.kapott.hbci.status.HBCIMsgStatus

            String country=passport.getCountry();
   
            passport.setSigId(new Long(1));
            passport.setSysId("0");
   
            HBCIMsgStatus ret=null;
            boolean       restarted=false;
            while (true) {
                kernel.rawNewMsg("Synch");
                kernel.rawSet("Idn.KIK.blz", blz);
                kernel.rawSet("Idn.KIK.country", country);
                kernel.rawSet("Idn.customerid", passport.getCustomerId());
                kernel.rawSet("Idn.sysid", "0");
                kernel.rawSet("Idn.sysStatus", "1");
                kernel.rawSet("MsgHead.dialogid", "0");
                kernel.rawSet("MsgHead.msgnum", "1");
                kernel.rawSet("MsgTail.msgnum", "1");
                kernel.rawSet("ProcPrep.BPD", passport.getBPDVersion());
                kernel.rawSet("ProcPrep.UPD", passport.getUPDVersion());
                kernel.rawSet("ProcPrep.lang", "0");
                kernel.rawSet("ProcPrep.prodName", HBCIUtils.getParam("client.product.name","HBCI4Java"));
                kernel.rawSet("ProcPrep.prodVersion", HBCIUtils.getParam("client.product.version","2.5"));
                kernel.rawSet("Sync.mode", "0");
                ret=kernel.rawDoIt(HBCIKernelImpl.SIGNIT,HBCIKernelImpl.CRYPTIT,
                        HBCIKernelImpl.NEED_SIG,HBCIKernelImpl.NEED_CRYPT);

                boolean need_restart=passport.postInitResponseHook(ret, passport.isAnonymous());
                if (need_restart) {
                    HBCIUtils.log("for some reason we have to restart this dialog", HBCIUtils.LOG_INFO);
                    if (restarted) {
                        HBCIUtils.log("this dialog already has been restarted once - to avoid endless loops we stop here", HBCIUtils.LOG_WARN);
                        throw new HBCI_Exception("*** restart loop - aborting");
                    }
                    restarted=true;
                } else {
                    break;
                }
            }
           
            Properties result=ret.getData();
           
            if (!ret.isOK())
                throw new ProcessException(HBCIUtilsInternal.getLocMsg("EXCMSG_SYNCSYSIDFAIL"),ret);
   
            HBCIInstitute inst=new HBCIInstitute(kernel,passport,false);
            inst.updateBPD(result);
            updateUPD(result);
View Full Code Here
TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.