www.pudn.com > d4j.zip > dialogicGC.c

/* $Id: dialogicGC.c,v 1.4 2003/11/13 11:57:25 cgm8 Exp $ */ 
 
/* 
 * DialogicGC.c: Dialogic GlobalCall interface to java 
 * Copyright (c) 1999 Carlos G Mendioroz. 
 * 
 *  This file is part of D4J. 
 * 
 *  D4J is free software; you can redistribute it and/or 
 *  modify it under the terms of the GNU Lesser General Public 
 *  License as published by the Free Software Foundation; either 
 *  version 2 of the License, or (at your option) any later version. 
 *   
 *  D4J is distributed in the hope that it will be useful, 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU 
 *  Lesser General Public License for more details. 
 *   
 *  You should have received a copy of the GNU Lesser General Public 
 *  License along with this library; if not, write to the 
 *  Free Software Foundation, Inc., 59 Temple Place - Suite 330, 
 *  Boston, MA  02111-1307, USA. 
 * 
 * Report problems and direct all questions to: 
 * 
 *	tron@acm.org 
 */ 
  
#ifndef LINUX 
#include  
#else 
#define O_BINARY 0 
#define dx_fileopen open 
#define dx_fileclose close 
#endif 
#include  
#include  
#include "DialogicGC.h" 
#include "srllib.h" 
#include "dxxxlib.h" 
#include "gclib.h" 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_Start 
 * Signature: ()I 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1Start 
  (JNIEnv *env, jclass class) { 
        gc_Start(0L); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_Stop 
 * Signature: ()I 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1Stop 
  (JNIEnv *env, jclass class) { 
        gc_Stop(); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_Open 
 * Signature: (Ljava/lang/String;)I 
 */ 
JNIEXPORT jint JNICALL Java_local_dialogic_GCChannel_gc_1Open 
  (JNIEnv *env, jclass class, jstring Sline) { 
    long line = 0; 
    int ret; 
    char *name; 
 
    name = (char *)(*env)->GetStringUTFChars(env, Sline, 0); 
 
    ret = gc_Open(&line, name, 0); 
    (*env)->ReleaseStringUTFChars(env, Sline, name); 
 
    if(ret) 
        return GCerror(env, "GCOpen"); 
    return line; 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_Close 
 * Signature: (I)I 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1Close 
  (JNIEnv *env, jclass class, jint Iline) { 
    if (gc_Close(Iline)) 
        GCerror(env, "Close"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_GetVoiceH 
 * Signature: (I)I 
 */ 
JNIEXPORT jint JNICALL Java_local_dialogic_GCChannel_gc_1GetVoiceH 
  (JNIEnv *env, jclass class, jint Iline) { 
    int voiceH; 
 
    if (gc_GetVoiceH(Iline, &voiceH)) 
        return GCerror(env, "GetVoiceH"); 
    return voiceH; 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_GetNetworkH 
 * Signature: (I)I 
 */ 
JNIEXPORT jint JNICALL Java_local_dialogic_GCChannel_gc_1GetNetworkH 
  (JNIEnv *env, jclass class, jint Iline) { 
    int netH; 
 
    if (gc_GetNetworkH(Iline, &netH)) 
        return GCerror(env, "GetNetworkH"); 
    return netH; 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_Attach 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1Attach 
  (JNIEnv *env, jclass class, jint Iline, jint Ivoice, jint Imode) { 
 
    if (gc_Attach(Iline, Ivoice, Imode)) 
        GCerror(env, "Attach"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_Detach 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1Detach 
  (JNIEnv *env, jclass class, jint Iline, jint Ivoice, jint Imode) { 
 
    if (gc_Detach(Iline, Ivoice, Imode)) 
        GCerror(env, "Dettach"); 
  } 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_WaitCall 
 * Signature: (III)I 
 */ 
JNIEXPORT jint JNICALL Java_local_dialogic_GCChannel_gc_1WaitCall 
  (JNIEnv *env, jclass class, jint Iline, jint Ito, jint Imode) { 
    long crn = 0; 
    long * crnp; 
 
    if (Imode == EV_ASYNC) 
        crnp = NULL; 
    else 
        crnp = &crn; 
 
    if (gc_WaitCall(Iline, crnp, NULL, Ito, Imode)) 
        return GCerror(env, "WaitCall"); 
    return crn; 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_AcceptCall 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1AcceptCall 
  (JNIEnv *env, jclass class, jint Icrn, jint Irings, jint Imode) { 
 
    if (gc_AcceptCall(Icrn, Irings, Imode)) 
        GCerror(env, "AcceptCall"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_AnswerCall 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1AnswerCall 
  (JNIEnv *env, jclass class, jint Icrn, jint Irings, jint Imode) { 
 
    if (gc_AnswerCall(Icrn, Irings, Imode)) 
        GCerror(env, "AnswerCall"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_CallAck 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1CallAck 
  (JNIEnv *env, jclass class, jint Icrn, jint Idnis, jint Imode) { 
    GC_CALLACK_BLK callack; 
    callack.type = GCACK_SERVICE_DNIS; 
    callack.service.dnis.accept = Idnis; 
 
    if (gc_CallAck(Icrn, &callack, Imode)) 
        GCerror(env, "CallAck"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_DropCall 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1DropCall 
  (JNIEnv *env, jclass class, jint Icrn, jint Icause, jint Imode) { 
 
    if (gc_DropCall(Icrn, Icause, Imode)) 
        GCerror(env, "DropCall"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_GetDNIS 
 * Signature: (I[B)V 
 */ 
JNIEXPORT jint JNICALL Java_local_dialogic_GCChannel_gc_1GetDNIS 
  (JNIEnv *env, jclass class, jint Icrn, jbyteArray BAbuf) { 
    char *bufp; 
    int l; 
 
    if ((*env)->GetArrayLength(env, BAbuf) < 5) { 
        throw(env, "java/lang/RuntimeException", "Small buffer for GetDNIS"); 
        return -1; 
    } 
    bufp = (*env)->GetByteArrayElements(env, BAbuf, 0); 
    if (gc_GetDNIS(Icrn, bufp)) { 
        GCerror(env, "GetDNIS"); 
        return -1; 
    } 
    l = strlen(bufp); 
    (*env)->ReleaseByteArrayElements(env, BAbuf, bufp, 0); 
    return l; 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_GetANI 
 * Signature: (I[B)V 
 */ 
JNIEXPORT jint JNICALL Java_local_dialogic_GCChannel_gc_1GetANI 
  (JNIEnv *env, jclass class, jint Icrn, jbyteArray BAbuf) { 
    char *bufp; 
    int l; 
 
    if ((*env)->GetArrayLength(env, BAbuf) < 15) { 
        throw(env, "java/lang/RuntimeException", "Small buffer for GetANI"); 
        return -1; 
    } 
    bufp = (*env)->GetByteArrayElements(env, BAbuf, 0); 
    if (gc_GetANI(Icrn, bufp)) { 
        GCerror(env, "GetANI"); 
        return -1; 
    } 
    l = strlen(bufp); 
    (*env)->ReleaseByteArrayElements(env, BAbuf, bufp, 0); 
    return l; 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_GetCallInfo 
 * Signature: (II[B)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1GetCallInfo 
  (JNIEnv *env, jclass class, jint Icrn, jint Iid, jbyteArray BAbuf) { 
    char buf[32], *bufp; 
    int l = 0; 
 
    if (gc_GetCallInfo(Icrn, Iid, buf)) { 
        GCerror(env, "GetCallInfo"); 
        return; 
    } 
 
 
    l = (*env)->GetArrayLength(env, BAbuf); 
    bufp = (*env)->GetByteArrayElements(env, BAbuf, 0); 
    strncpy(bufp, buf, l); 
    (*env)->ReleaseByteArrayElements(env, BAbuf, bufp, 0); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_GetParm 
 * Signature: (II)I 
 */ 
JNIEXPORT jint JNICALL Java_local_dialogic_GCChannel_gc_1GetParm 
  (JNIEnv *env, jclass class, jint Iline, jint Iid) { 
    GC_PARM parm; 
 
    if (gc_GetParm(Iline, Iid, &parm)) 
        return GCerror(env, "GetParm"); 
    return parm.longvalue; 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_SetParm 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1SetParm 
  (JNIEnv *env, jclass class, jint Iline, jint Iid, jint Ival) { 
    GC_PARM parm; 
 
    parm.longvalue = Ival; 
    if (gc_SetParm(Iline, Iid, parm)) 
        GCerror(env, "SetParm"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_MakeCall 
 * Signature: (ILjava/lang/String;II)I 
 */ 
JNIEXPORT jint JNICALL Java_local_dialogic_GCChannel_gc_1MakeCall 
  (JNIEnv *env, jclass class, jint Iline, jstring Snumber, jint Ito, jint Imode) { 
    char * number; 
    long crn; 
 
    number = (char *)(*env)->GetStringUTFChars(env, Snumber, 0); 
 
    if (gc_MakeCall(Iline, &crn, number, 0L, Ito, Imode)) { 
        GCerror(env, "MakeCall"); 
    } 
    (*env)->ReleaseStringUTFChars(env, Snumber, number); 
    return crn; 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_ReleaseCall 
 * Signature: (I)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1ReleaseCall 
  (JNIEnv *env, jclass class, jint Icrn) { 
    if (gc_ReleaseCall(Icrn)) 
        GCerror(env, "ReleaseCall"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_ResetLineDev 
 * Signature: (II)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1ResetLineDev 
  (JNIEnv *env, jclass class, jint Iline, jint Imode) { 
    if (gc_ResetLineDev(Iline, Imode)) 
        GCerror(env, "ResetLineDev"); 
  } 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_SetBilling 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1SetBilling 
  (JNIEnv *env, jclass class, jint Icrn, jint Irate, jint Imode) { 
 
    if (gc_SetBilling(Icrn, Irate, 0L, Imode)) 
        GCerror(env, "SetBilling"); 
  } 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_SetChanState 
 * Signature: (III)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1SetChanState 
  (JNIEnv *env, jclass class, jint Iline, jint Istate, jint Imode) { 
 
    if (gc_SetChanState(Iline, Istate, Imode)) 
        GCerror(env, "SetChanState"); 
  } 
 
static jclass evtClass = 0; 
static jfieldID evtDevID = 0; 
static jfieldID evtTypeID = 0; 
static jfieldID evtTermmskID = 0; 
static jfieldID evtCstevtID = 0; 
static jfieldID evtCstdataID = 0; 
static jfieldID evtDataID = 0; 
static jfieldID evtLineID = 0; 
static jfieldID evtCRNID = 0; 
struct DX_CST { 
   unsigned short cst_event; 
   unsigned short cst_data; 
} *rs_getevtdata(); 
 
/* 
 * Class:     local_dialogic_GCChannel 
 * Method:    gc_waitevt 
 * Signature: (Llocal/dialogic/EVT;)V 
 */ 
JNIEXPORT void JNICALL Java_local_dialogic_GCChannel_gc_1getMeta 
  (JNIEnv *env, jclass class, jobject Oevt) 
{ 
    METAEVENT meta; 
 
    if (evtClass == 0) { 
        jclass clst; 
        clst = (*env)->GetObjectClass(env, Oevt); 
        if (clst == 0) { 
            throw(env, "java/lang/RuntimeException", 
                "Class EVT not found!"); 
            return; 
        } 
        evtClass = (*env)->NewGlobalRef(env, clst); 
        if (evtClass == 0) { 
            throw(env, "java/lang/RuntimeException", 
                        "Class EVT reference error!"); 
            return; 
        } 
 
        evtDevID = (*env)->GetFieldID(env, evtClass, "dev", "I"); 
        evtTypeID = (*env)->GetFieldID(env, evtClass, "type", "I"); 
        evtTermmskID = (*env)->GetFieldID(env, evtClass, "termmsk", "I"); 
        evtCstevtID = (*env)->GetFieldID(env, evtClass, "cstevt", "I"); 
        evtCstdataID = (*env)->GetFieldID(env, evtClass, "cstdata", "I"); 
        evtDataID = (*env)->GetFieldID(env, evtClass, "data", "I"); 
        evtLineID = (*env)->GetFieldID(env, evtClass, "line", "I"); 
        evtCRNID = (*env)->GetFieldID(env, evtClass, "crn", "J"); 
    } 
    gc_GetMetaEvent(&meta); 
    (*env)->SetIntField(env, Oevt, evtLineID, meta.linedev); 
    (*env)->SetIntField(env, Oevt, evtCRNID, meta.crn); 
} 
 
 
GCerror(JNIEnv env, char *where) 
{ 
    int gcerror = 0, cclib = 0; 
    long ccerror = 0; 
    char errbuf[128]; 
    gc_ErrorValue(&gcerror, &cclib, &ccerror); 
     
    sprintf(errbuf, "%s: (0x%x/0x%x/0x%x)", where, gcerror, cclib, ccerror); 
    throw(env, "java/lang/RuntimeException", errbuf); 
    return -1; 
} 
 
throw(JNIEnv *env, char * which, char *what, long par1, long par2, long par3, long par4) 
{ 
    jclass newExcCls; 
    char errbuf[128]; 
 
   newExcCls = (*env)->FindClass(env, which); 
   if (newExcCls == 0)  return 0; 
   sprintf(errbuf, what, par1, par2, par3, par4); 
   (*env)->ThrowNew(env, newExcCls, errbuf); 
}