mirror of
https://github.com/signalwire/freeswitch.git
synced 2026-11-16 06:18:35 +00:00
Merge branch 'master' into smgmaster
Conflicts: build/modules.conf.in
This commit is contained in:
commit
2a9046fdb8
608 files changed
+33546
-20511
No files matched your search
+2
-2
@@ -34,10 +34,10 @@ testclient: $(MYLIB) testclient.c
|
||||
fs_cli: $(MYLIB) fs_cli.c
|
||||
$(CC) $(CC_CFLAGS) $(CFLAGS) fs_cli.c -o fs_cli $(LDFLAGS) -L$(LIBEDIT_DIR)/src/.libs $(LIBS) -ledit
|
||||
|
||||
%.o: %.c
|
||||
%.o: %.c $(HEADERS)
|
||||
$(CC) $(CC_CFLAGS) $(CFLAGS) -c $< -o $@
|
||||
|
||||
%.o: %.cpp
|
||||
%.o: %.cpp $(HEADERS)
|
||||
$(CXX) $(CXX_CFLAGS) $(CXXFLAGS) -c $< -o $@
|
||||
|
||||
clean:
|
||||
|
||||
+20
-5
@@ -572,7 +572,7 @@ COLORS[] = { ESL_SEQ_DEFAULT_COLOR, ESL_SEQ_FRED, ESL_SEQ_FRED,
|
||||
ESL_SEQ_FRED, ESL_SEQ_FMAGEN, ESL_SEQ_FCYAN, ESL_SEQ_FGREEN, ESL_SEQ_FYELLOW };
|
||||
|
||||
static int usage(char *name){
|
||||
printf("Usage: %s [-H <host>] [-P <port>] [-p <secret>] [-d <level>] [-x command] [profile]\n\n", name);
|
||||
printf("Usage: %s [-H <host>] [-P <port>] [-p <secret>] [-d <level>] [-x command] [-t <timeout_ms>] [profile]\n\n", name);
|
||||
printf(" -?,-h --help Usage Information\n");
|
||||
printf(" -H, --host=hostname Host to connect\n");
|
||||
printf(" -P, --port=port Port to connect (1 - 65535)\n");
|
||||
@@ -584,7 +584,8 @@ static int usage(char *name){
|
||||
printf(" -q, --quiet Disable logging\n");
|
||||
printf(" -r, --retry Retry connection on failure\n");
|
||||
printf(" -R, --reconnect Reconnect if disconnected\n");
|
||||
printf(" -d, --debug=level Debug Level (0 - 7)\n\n");
|
||||
printf(" -d, --debug=level Debug Level (0 - 7)\n");
|
||||
printf(" -t, --timeout Timeout for API commands (in miliseconds)\n\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
@@ -1026,6 +1027,7 @@ int main(int argc, char *argv[])
|
||||
{"retry", 0, 0, 'r'},
|
||||
{"interrupt", 0, 0, 'i'},
|
||||
{"reconnect", 0, 0, 'R'},
|
||||
{"timeout", 1, 0, 't'},
|
||||
{0, 0, 0, 0}
|
||||
};
|
||||
|
||||
@@ -1044,7 +1046,7 @@ int main(int argc, char *argv[])
|
||||
char argv_command[1024] = "";
|
||||
char argv_loglevel[128] = "";
|
||||
int argv_quiet = 0;
|
||||
int loops = 2, reconnect = 0;
|
||||
int loops = 2, reconnect = 0, timeout = 0;
|
||||
|
||||
strncpy(internal_profile.host, "127.0.0.1", sizeof(internal_profile.host));
|
||||
strncpy(internal_profile.pass, "ClueCon", sizeof(internal_profile.pass));
|
||||
@@ -1069,7 +1071,7 @@ int main(int argc, char *argv[])
|
||||
|
||||
for(;;) {
|
||||
int option_index = 0;
|
||||
opt = getopt_long(argc, argv, "H:U:P:S:u:p:d:x:l:qrRhi?", options, &option_index);
|
||||
opt = getopt_long(argc, argv, "H:U:P:S:u:p:d:x:l:t:qrRhi?", options, &option_index);
|
||||
if (opt == -1) break;
|
||||
switch (opt)
|
||||
{
|
||||
@@ -1122,6 +1124,9 @@ int main(int argc, char *argv[])
|
||||
case 'R':
|
||||
reconnect = 1;
|
||||
break;
|
||||
case 't':
|
||||
timeout = atoi(optarg);
|
||||
break;
|
||||
case 'h':
|
||||
case '?':
|
||||
print_banner(stdout);
|
||||
@@ -1278,7 +1283,17 @@ int main(int argc, char *argv[])
|
||||
const char *err = NULL;
|
||||
|
||||
snprintf(cmd_str, sizeof(cmd_str), "api %s\n\n", argv_command);
|
||||
esl_send_recv(&handle, cmd_str);
|
||||
if (timeout) {
|
||||
esl_status_t status = esl_send_recv_timed(&handle, cmd_str, timeout);
|
||||
if (status != ESL_SUCCESS) {
|
||||
printf("Request timed out.\n");
|
||||
esl_disconnect(&handle);
|
||||
return -2;
|
||||
}
|
||||
} else {
|
||||
esl_send_recv(&handle, cmd_str);
|
||||
}
|
||||
|
||||
if (handle.last_sr_event) {
|
||||
if (handle.last_sr_event->body) {
|
||||
printf("%s\n", handle.last_sr_event->body);
|
||||
|
||||
@@ -419,10 +419,11 @@ SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1setPriority
|
||||
}
|
||||
|
||||
|
||||
SWIGEXPORT jstring JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1getHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
|
||||
SWIGEXPORT jstring JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1getHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
|
||||
jstring jresult = 0 ;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
int arg3 = (int) -1 ;
|
||||
char *result = 0 ;
|
||||
|
||||
(void)jenv;
|
||||
@@ -434,7 +435,8 @@ SWIGEXPORT jstring JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1getHeader(JN
|
||||
arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
|
||||
if (!arg2) return 0;
|
||||
}
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2);
|
||||
arg3 = (int)jarg3;
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2,arg3);
|
||||
if(result) jresult = jenv->NewStringUTF((const char *)result);
|
||||
if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
|
||||
return jresult;
|
||||
@@ -522,6 +524,64 @@ SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1addHeader(J
|
||||
}
|
||||
|
||||
|
||||
SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1pushHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
|
||||
jboolean jresult = 0 ;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
|
||||
(void)jenv;
|
||||
(void)jcls;
|
||||
(void)jarg1_;
|
||||
arg1 = *(ESLevent **)&jarg1;
|
||||
arg2 = 0;
|
||||
if (jarg2) {
|
||||
arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
|
||||
if (!arg2) return 0;
|
||||
}
|
||||
arg3 = 0;
|
||||
if (jarg3) {
|
||||
arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
|
||||
if (!arg3) return 0;
|
||||
}
|
||||
result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3);
|
||||
jresult = (jboolean)result;
|
||||
if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
|
||||
if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
|
||||
return jresult;
|
||||
}
|
||||
|
||||
|
||||
SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1unshiftHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
|
||||
jboolean jresult = 0 ;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
|
||||
(void)jenv;
|
||||
(void)jcls;
|
||||
(void)jarg1_;
|
||||
arg1 = *(ESLevent **)&jarg1;
|
||||
arg2 = 0;
|
||||
if (jarg2) {
|
||||
arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
|
||||
if (!arg2) return 0;
|
||||
}
|
||||
arg3 = 0;
|
||||
if (jarg3) {
|
||||
arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
|
||||
if (!arg3) return 0;
|
||||
}
|
||||
result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3);
|
||||
jresult = (jboolean)result;
|
||||
if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
|
||||
if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
|
||||
return jresult;
|
||||
}
|
||||
|
||||
|
||||
SWIGEXPORT jboolean JNICALL Java_org_freeswitch_esl_eslJNI_ESLevent_1delHeader(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
|
||||
jboolean jresult = 0 ;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
|
||||
@@ -78,8 +78,8 @@ public class ESLevent {
|
||||
return eslJNI.ESLevent_setPriority(swigCPtr, this, SWIGTYPE_p_esl_priority_t.getCPtr(priority));
|
||||
}
|
||||
|
||||
public String getHeader(String header_name) {
|
||||
return eslJNI.ESLevent_getHeader(swigCPtr, this, header_name);
|
||||
public String getHeader(String header_name, int idx) {
|
||||
return eslJNI.ESLevent_getHeader(swigCPtr, this, header_name, idx);
|
||||
}
|
||||
|
||||
public String getBody() {
|
||||
@@ -98,6 +98,14 @@ public class ESLevent {
|
||||
return eslJNI.ESLevent_addHeader(swigCPtr, this, header_name, value);
|
||||
}
|
||||
|
||||
public boolean pushHeader(String header_name, String value) {
|
||||
return eslJNI.ESLevent_pushHeader(swigCPtr, this, header_name, value);
|
||||
}
|
||||
|
||||
public boolean unshiftHeader(String header_name, String value) {
|
||||
return eslJNI.ESLevent_unshiftHeader(swigCPtr, this, header_name, value);
|
||||
}
|
||||
|
||||
public boolean delHeader(String header_name) {
|
||||
return eslJNI.ESLevent_delHeader(swigCPtr, this, header_name);
|
||||
}
|
||||
|
||||
@@ -21,11 +21,13 @@ class eslJNI {
|
||||
public final static native void delete_ESLevent(long jarg1);
|
||||
public final static native String ESLevent_serialize(long jarg1, ESLevent jarg1_, String jarg2);
|
||||
public final static native boolean ESLevent_setPriority(long jarg1, ESLevent jarg1_, long jarg2);
|
||||
public final static native String ESLevent_getHeader(long jarg1, ESLevent jarg1_, String jarg2);
|
||||
public final static native String ESLevent_getHeader(long jarg1, ESLevent jarg1_, String jarg2, int jarg3);
|
||||
public final static native String ESLevent_getBody(long jarg1, ESLevent jarg1_);
|
||||
public final static native String ESLevent_getType(long jarg1, ESLevent jarg1_);
|
||||
public final static native boolean ESLevent_addBody(long jarg1, ESLevent jarg1_, String jarg2);
|
||||
public final static native boolean ESLevent_addHeader(long jarg1, ESLevent jarg1_, String jarg2, String jarg3);
|
||||
public final static native boolean ESLevent_pushHeader(long jarg1, ESLevent jarg1_, String jarg2, String jarg3);
|
||||
public final static native boolean ESLevent_unshiftHeader(long jarg1, ESLevent jarg1_, String jarg2, String jarg3);
|
||||
public final static native boolean ESLevent_delHeader(long jarg1, ESLevent jarg1_, String jarg2);
|
||||
public final static native String ESLevent_firstHeader(long jarg1, ESLevent jarg1_);
|
||||
public final static native String ESLevent_nextHeader(long jarg1, ESLevent jarg1_);
|
||||
|
||||
@@ -1923,18 +1923,23 @@ static int _wrap_ESLevent_getHeader(lua_State* L) {
|
||||
int SWIG_arg = -1;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
int arg3 = (int) -1 ;
|
||||
char *result = 0 ;
|
||||
|
||||
SWIG_check_num_args("getHeader",2,2)
|
||||
SWIG_check_num_args("getHeader",2,3)
|
||||
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("getHeader",1,"ESLevent *");
|
||||
if(!lua_isstring(L,2)) SWIG_fail_arg("getHeader",2,"char const *");
|
||||
if(lua_gettop(L)>=3 && !lua_isnumber(L,3)) SWIG_fail_arg("getHeader",3,"int");
|
||||
|
||||
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ESLevent,0))){
|
||||
SWIG_fail_ptr("ESLevent_getHeader",1,SWIGTYPE_p_ESLevent);
|
||||
}
|
||||
|
||||
arg2 = (char *)lua_tostring(L, 2);
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2);
|
||||
if(lua_gettop(L)>=3){
|
||||
arg3 = (int)lua_tonumber(L, 3);
|
||||
}
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2,arg3);
|
||||
SWIG_arg=0;
|
||||
lua_pushstring(L,(const char*)result); SWIG_arg++;
|
||||
return SWIG_arg;
|
||||
@@ -2056,6 +2061,68 @@ fail:
|
||||
}
|
||||
|
||||
|
||||
static int _wrap_ESLevent_pushHeader(lua_State* L) {
|
||||
int SWIG_arg = -1;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
|
||||
SWIG_check_num_args("pushHeader",3,3)
|
||||
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("pushHeader",1,"ESLevent *");
|
||||
if(!lua_isstring(L,2)) SWIG_fail_arg("pushHeader",2,"char const *");
|
||||
if(!lua_isstring(L,3)) SWIG_fail_arg("pushHeader",3,"char const *");
|
||||
|
||||
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ESLevent,0))){
|
||||
SWIG_fail_ptr("ESLevent_pushHeader",1,SWIGTYPE_p_ESLevent);
|
||||
}
|
||||
|
||||
arg2 = (char *)lua_tostring(L, 2);
|
||||
arg3 = (char *)lua_tostring(L, 3);
|
||||
result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3);
|
||||
SWIG_arg=0;
|
||||
lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
|
||||
return SWIG_arg;
|
||||
|
||||
if(0) SWIG_fail;
|
||||
|
||||
fail:
|
||||
lua_error(L);
|
||||
return SWIG_arg;
|
||||
}
|
||||
|
||||
|
||||
static int _wrap_ESLevent_unshiftHeader(lua_State* L) {
|
||||
int SWIG_arg = -1;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
|
||||
SWIG_check_num_args("unshiftHeader",3,3)
|
||||
if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("unshiftHeader",1,"ESLevent *");
|
||||
if(!lua_isstring(L,2)) SWIG_fail_arg("unshiftHeader",2,"char const *");
|
||||
if(!lua_isstring(L,3)) SWIG_fail_arg("unshiftHeader",3,"char const *");
|
||||
|
||||
if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ESLevent,0))){
|
||||
SWIG_fail_ptr("ESLevent_unshiftHeader",1,SWIGTYPE_p_ESLevent);
|
||||
}
|
||||
|
||||
arg2 = (char *)lua_tostring(L, 2);
|
||||
arg3 = (char *)lua_tostring(L, 3);
|
||||
result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3);
|
||||
SWIG_arg=0;
|
||||
lua_pushboolean(L,(int)(result==true)); SWIG_arg++;
|
||||
return SWIG_arg;
|
||||
|
||||
if(0) SWIG_fail;
|
||||
|
||||
fail:
|
||||
lua_error(L);
|
||||
return SWIG_arg;
|
||||
}
|
||||
|
||||
|
||||
static int _wrap_ESLevent_delHeader(lua_State* L) {
|
||||
int SWIG_arg = -1;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
@@ -2146,6 +2213,8 @@ static swig_lua_method swig_ESLevent_methods[] = {
|
||||
{"getType", _wrap_ESLevent_getType},
|
||||
{"addBody", _wrap_ESLevent_addBody},
|
||||
{"addHeader", _wrap_ESLevent_addHeader},
|
||||
{"pushHeader", _wrap_ESLevent_pushHeader},
|
||||
{"unshiftHeader", _wrap_ESLevent_unshiftHeader},
|
||||
{"delHeader", _wrap_ESLevent_delHeader},
|
||||
{"firstHeader", _wrap_ESLevent_firstHeader},
|
||||
{"nextHeader", _wrap_ESLevent_nextHeader},
|
||||
|
||||
@@ -221,7 +221,7 @@ class ESLPINVOKE {
|
||||
public static extern bool ESLevent_SetPriority(HandleRef jarg1, HandleRef jarg2);
|
||||
|
||||
[DllImport("ESL", EntryPoint="CSharp_ESLevent_GetHeader")]
|
||||
public static extern string ESLevent_GetHeader(HandleRef jarg1, string jarg2);
|
||||
public static extern string ESLevent_GetHeader(HandleRef jarg1, string jarg2, int jarg3);
|
||||
|
||||
[DllImport("ESL", EntryPoint="CSharp_ESLevent_GetBody")]
|
||||
public static extern string ESLevent_GetBody(HandleRef jarg1);
|
||||
@@ -235,6 +235,12 @@ class ESLPINVOKE {
|
||||
[DllImport("ESL", EntryPoint="CSharp_ESLevent_AddHeader")]
|
||||
public static extern bool ESLevent_AddHeader(HandleRef jarg1, string jarg2, string jarg3);
|
||||
|
||||
[DllImport("ESL", EntryPoint="CSharp_ESLevent_pushHeader")]
|
||||
public static extern bool ESLevent_pushHeader(HandleRef jarg1, string jarg2, string jarg3);
|
||||
|
||||
[DllImport("ESL", EntryPoint="CSharp_ESLevent_unshiftHeader")]
|
||||
public static extern bool ESLevent_unshiftHeader(HandleRef jarg1, string jarg2, string jarg3);
|
||||
|
||||
[DllImport("ESL", EntryPoint="CSharp_ESLevent_DelHeader")]
|
||||
public static extern bool ESLevent_DelHeader(HandleRef jarg1, string jarg2);
|
||||
|
||||
|
||||
@@ -89,8 +89,8 @@ public class ESLevent : IDisposable {
|
||||
return ret;
|
||||
}
|
||||
|
||||
public string GetHeader(string header_name) {
|
||||
string ret = ESLPINVOKE.ESLevent_GetHeader(swigCPtr, header_name);
|
||||
public string GetHeader(string header_name, int idx) {
|
||||
string ret = ESLPINVOKE.ESLevent_GetHeader(swigCPtr, header_name, idx);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@@ -114,6 +114,16 @@ public class ESLevent : IDisposable {
|
||||
return ret;
|
||||
}
|
||||
|
||||
public bool pushHeader(string header_name, string value) {
|
||||
bool ret = ESLPINVOKE.ESLevent_pushHeader(swigCPtr, header_name, value);
|
||||
return ret;
|
||||
}
|
||||
|
||||
public bool unshiftHeader(string header_name, string value) {
|
||||
bool ret = ESLPINVOKE.ESLevent_unshiftHeader(swigCPtr, header_name, value);
|
||||
return ret;
|
||||
}
|
||||
|
||||
public bool DelHeader(string header_name) {
|
||||
bool ret = ESLPINVOKE.ESLevent_DelHeader(swigCPtr, header_name);
|
||||
return ret;
|
||||
|
||||
@@ -436,15 +436,17 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_SetPriority(void * jarg1, vo
|
||||
}
|
||||
|
||||
|
||||
SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_GetHeader(void * jarg1, char * jarg2) {
|
||||
SWIGEXPORT char * SWIGSTDCALL CSharp_ESLevent_GetHeader(void * jarg1, char * jarg2, int jarg3) {
|
||||
char * jresult ;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
int arg3 = (int) -1 ;
|
||||
char *result = 0 ;
|
||||
|
||||
arg1 = (ESLevent *)jarg1;
|
||||
arg2 = (char *)jarg2;
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2);
|
||||
arg3 = (int)jarg3;
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2,arg3);
|
||||
jresult = SWIG_csharp_string_callback((const char *)result);
|
||||
return jresult;
|
||||
}
|
||||
@@ -504,6 +506,38 @@ SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_AddHeader(void * jarg1, char
|
||||
}
|
||||
|
||||
|
||||
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_pushHeader(void * jarg1, char * jarg2, char * jarg3) {
|
||||
unsigned int jresult ;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
|
||||
arg1 = (ESLevent *)jarg1;
|
||||
arg2 = (char *)jarg2;
|
||||
arg3 = (char *)jarg3;
|
||||
result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3);
|
||||
jresult = result;
|
||||
return jresult;
|
||||
}
|
||||
|
||||
|
||||
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_unshiftHeader(void * jarg1, char * jarg2, char * jarg3) {
|
||||
unsigned int jresult ;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
|
||||
arg1 = (ESLevent *)jarg1;
|
||||
arg2 = (char *)jarg2;
|
||||
arg3 = (char *)jarg3;
|
||||
result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3);
|
||||
jresult = result;
|
||||
return jresult;
|
||||
}
|
||||
|
||||
|
||||
SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ESLevent_DelHeader(void * jarg1, char * jarg2) {
|
||||
unsigned int jresult ;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
|
||||
@@ -88,6 +88,8 @@ sub DESTROY {
|
||||
*getType = *ESLc::ESLevent_getType;
|
||||
*addBody = *ESLc::ESLevent_addBody;
|
||||
*addHeader = *ESLc::ESLevent_addHeader;
|
||||
*pushHeader = *ESLc::ESLevent_pushHeader;
|
||||
*unshiftHeader = *ESLc::ESLevent_unshiftHeader;
|
||||
*delHeader = *ESLc::ESLevent_delHeader;
|
||||
*firstHeader = *ESLc::ESLevent_firstHeader;
|
||||
*nextHeader = *ESLc::ESLevent_nextHeader;
|
||||
|
||||
+117
-3
@@ -2285,17 +2285,20 @@ XS(_wrap_ESLevent_getHeader) {
|
||||
{
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
int arg3 = (int) -1 ;
|
||||
char *result = 0 ;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int val3 ;
|
||||
int ecode3 = 0 ;
|
||||
int argvi = 0;
|
||||
dXSARGS;
|
||||
|
||||
if ((items < 2) || (items > 2)) {
|
||||
SWIG_croak("Usage: ESLevent_getHeader(self,header_name);");
|
||||
if ((items < 2) || (items > 3)) {
|
||||
SWIG_croak("Usage: ESLevent_getHeader(self,header_name,idx);");
|
||||
}
|
||||
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
if (!SWIG_IsOK(res1)) {
|
||||
@@ -2307,14 +2310,23 @@ XS(_wrap_ESLevent_getHeader) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_getHeader" "', argument " "2"" of type '" "char const *""'");
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2);
|
||||
if (items > 2) {
|
||||
ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
|
||||
if (!SWIG_IsOK(ecode3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ESLevent_getHeader" "', argument " "3"" of type '" "int""'");
|
||||
}
|
||||
arg3 = static_cast< int >(val3);
|
||||
}
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2,arg3);
|
||||
ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
|
||||
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
|
||||
XSRETURN(argvi);
|
||||
fail:
|
||||
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
|
||||
SWIG_croak_null();
|
||||
}
|
||||
}
|
||||
@@ -2465,6 +2477,106 @@ XS(_wrap_ESLevent_addHeader) {
|
||||
}
|
||||
|
||||
|
||||
XS(_wrap_ESLevent_pushHeader) {
|
||||
{
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int res3 ;
|
||||
char *buf3 = 0 ;
|
||||
int alloc3 = 0 ;
|
||||
int argvi = 0;
|
||||
dXSARGS;
|
||||
|
||||
if ((items < 3) || (items > 3)) {
|
||||
SWIG_croak("Usage: ESLevent_pushHeader(self,header_name,value);");
|
||||
}
|
||||
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
if (!SWIG_IsOK(res1)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_pushHeader" "', argument " "1"" of type '" "ESLevent *""'");
|
||||
}
|
||||
arg1 = reinterpret_cast< ESLevent * >(argp1);
|
||||
res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
|
||||
if (!SWIG_IsOK(res2)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_pushHeader" "', argument " "2"" of type '" "char const *""'");
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
|
||||
if (!SWIG_IsOK(res3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ESLevent_pushHeader" "', argument " "3"" of type '" "char const *""'");
|
||||
}
|
||||
arg3 = reinterpret_cast< char * >(buf3);
|
||||
result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3);
|
||||
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
|
||||
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
XSRETURN(argvi);
|
||||
fail:
|
||||
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
SWIG_croak_null();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
XS(_wrap_ESLevent_unshiftHeader) {
|
||||
{
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int res3 ;
|
||||
char *buf3 = 0 ;
|
||||
int alloc3 = 0 ;
|
||||
int argvi = 0;
|
||||
dXSARGS;
|
||||
|
||||
if ((items < 3) || (items > 3)) {
|
||||
SWIG_croak("Usage: ESLevent_unshiftHeader(self,header_name,value);");
|
||||
}
|
||||
res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
if (!SWIG_IsOK(res1)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_unshiftHeader" "', argument " "1"" of type '" "ESLevent *""'");
|
||||
}
|
||||
arg1 = reinterpret_cast< ESLevent * >(argp1);
|
||||
res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
|
||||
if (!SWIG_IsOK(res2)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_unshiftHeader" "', argument " "2"" of type '" "char const *""'");
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
|
||||
if (!SWIG_IsOK(res3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ESLevent_unshiftHeader" "', argument " "3"" of type '" "char const *""'");
|
||||
}
|
||||
arg3 = reinterpret_cast< char * >(buf3);
|
||||
result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3);
|
||||
ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1(static_cast< bool >(result)); argvi++ ;
|
||||
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
XSRETURN(argvi);
|
||||
fail:
|
||||
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
SWIG_croak_null();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
XS(_wrap_ESLevent_delHeader) {
|
||||
{
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
@@ -3658,6 +3770,8 @@ static swig_command_info swig_commands[] = {
|
||||
{"ESLc::ESLevent_getType", _wrap_ESLevent_getType},
|
||||
{"ESLc::ESLevent_addBody", _wrap_ESLevent_addBody},
|
||||
{"ESLc::ESLevent_addHeader", _wrap_ESLevent_addHeader},
|
||||
{"ESLc::ESLevent_pushHeader", _wrap_ESLevent_pushHeader},
|
||||
{"ESLc::ESLevent_unshiftHeader", _wrap_ESLevent_unshiftHeader},
|
||||
{"ESLc::ESLevent_delHeader", _wrap_ESLevent_delHeader},
|
||||
{"ESLc::ESLevent_firstHeader", _wrap_ESLevent_firstHeader},
|
||||
{"ESLc::ESLevent_nextHeader", _wrap_ESLevent_nextHeader},
|
||||
|
||||
+10
-2
@@ -76,8 +76,8 @@ class ESLevent {
|
||||
return $r;
|
||||
}
|
||||
|
||||
function getHeader($header_name) {
|
||||
return ESLevent_getHeader($this->_cPtr,$header_name);
|
||||
function getHeader($header_name,$idx=-1) {
|
||||
return ESLevent_getHeader($this->_cPtr,$header_name,$idx);
|
||||
}
|
||||
|
||||
function getBody() {
|
||||
@@ -96,6 +96,14 @@ class ESLevent {
|
||||
return ESLevent_addHeader($this->_cPtr,$header_name,$value);
|
||||
}
|
||||
|
||||
function pushHeader($header_name,$value) {
|
||||
return ESLevent_pushHeader($this->_cPtr,$header_name,$value);
|
||||
}
|
||||
|
||||
function unshiftHeader($header_name,$value) {
|
||||
return ESLevent_unshiftHeader($this->_cPtr,$header_name,$value);
|
||||
}
|
||||
|
||||
function delHeader($header_name) {
|
||||
return ESLevent_delHeader($this->_cPtr,$header_name);
|
||||
}
|
||||
|
||||
@@ -1445,13 +1445,16 @@ fail:
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_getHeader) {
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
int arg3 = (int) -1 ;
|
||||
char *result = 0 ;
|
||||
zval **args[2];
|
||||
zval **args[3];
|
||||
int arg_count;
|
||||
|
||||
SWIG_ResetError();
|
||||
if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {
|
||||
WRONG_PARAM_COUNT;
|
||||
}
|
||||
arg_count = ZEND_NUM_ARGS();
|
||||
if(arg_count<2 || arg_count>3 ||
|
||||
zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)
|
||||
WRONG_PARAM_COUNT;
|
||||
|
||||
{
|
||||
if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_ESLevent, 0) < 0) {
|
||||
@@ -1465,7 +1468,14 @@ ZEND_NAMED_FUNCTION(_wrap_ESLevent_getHeader) {
|
||||
arg2 = (char *) Z_STRVAL_PP(args[1]);
|
||||
/*@SWIG@*/;
|
||||
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2);
|
||||
if(arg_count > 2) {
|
||||
/*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,7,CONVERT_INT_IN@*/
|
||||
convert_to_long_ex(args[2]);
|
||||
arg3 = (int) Z_LVAL_PP(args[2]);
|
||||
/*@SWIG@*/;
|
||||
|
||||
}
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2,arg3);
|
||||
{
|
||||
if(!result) {
|
||||
ZVAL_NULL(return_value);
|
||||
@@ -1612,6 +1622,86 @@ fail:
|
||||
}
|
||||
|
||||
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_pushHeader) {
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
zval **args[3];
|
||||
|
||||
SWIG_ResetError();
|
||||
if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
|
||||
WRONG_PARAM_COUNT;
|
||||
}
|
||||
|
||||
{
|
||||
if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_ESLevent, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of ESLevent_pushHeader. Expected SWIGTYPE_p_ESLevent");
|
||||
}
|
||||
}
|
||||
if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
|
||||
|
||||
/*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,26,CONVERT_STRING_IN@*/
|
||||
convert_to_string_ex(args[1]);
|
||||
arg2 = (char *) Z_STRVAL_PP(args[1]);
|
||||
/*@SWIG@*/;
|
||||
|
||||
|
||||
/*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,26,CONVERT_STRING_IN@*/
|
||||
convert_to_string_ex(args[2]);
|
||||
arg3 = (char *) Z_STRVAL_PP(args[2]);
|
||||
/*@SWIG@*/;
|
||||
|
||||
result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3);
|
||||
{
|
||||
ZVAL_BOOL(return_value,(result)?1:0);
|
||||
}
|
||||
return;
|
||||
fail:
|
||||
zend_error(SWIG_ErrorCode(),SWIG_ErrorMsg());
|
||||
}
|
||||
|
||||
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_unshiftHeader) {
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
zval **args[3];
|
||||
|
||||
SWIG_ResetError();
|
||||
if(ZEND_NUM_ARGS() != 3 || zend_get_parameters_array_ex(3, args) != SUCCESS) {
|
||||
WRONG_PARAM_COUNT;
|
||||
}
|
||||
|
||||
{
|
||||
if(SWIG_ConvertPtr(*args[0], (void **) &arg1, SWIGTYPE_p_ESLevent, 0) < 0) {
|
||||
SWIG_PHP_Error(E_ERROR, "Type error in argument 1 of ESLevent_unshiftHeader. Expected SWIGTYPE_p_ESLevent");
|
||||
}
|
||||
}
|
||||
if(!arg1) SWIG_PHP_Error(E_ERROR, "this pointer is NULL");
|
||||
|
||||
/*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,26,CONVERT_STRING_IN@*/
|
||||
convert_to_string_ex(args[1]);
|
||||
arg2 = (char *) Z_STRVAL_PP(args[1]);
|
||||
/*@SWIG@*/;
|
||||
|
||||
|
||||
/*@SWIG:/usr/local/share/swig/1.3.35/php4/utils.i,26,CONVERT_STRING_IN@*/
|
||||
convert_to_string_ex(args[2]);
|
||||
arg3 = (char *) Z_STRVAL_PP(args[2]);
|
||||
/*@SWIG@*/;
|
||||
|
||||
result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3);
|
||||
{
|
||||
ZVAL_BOOL(return_value,(result)?1:0);
|
||||
}
|
||||
return;
|
||||
fail:
|
||||
zend_error(SWIG_ErrorCode(),SWIG_ErrorMsg());
|
||||
}
|
||||
|
||||
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_delHeader) {
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
@@ -2547,6 +2637,8 @@ static zend_function_entry ESL_functions[] = {
|
||||
SWIG_ZEND_NAMED_FE(eslevent_gettype,_wrap_ESLevent_getType,NULL)
|
||||
SWIG_ZEND_NAMED_FE(eslevent_addbody,_wrap_ESLevent_addBody,NULL)
|
||||
SWIG_ZEND_NAMED_FE(eslevent_addheader,_wrap_ESLevent_addHeader,NULL)
|
||||
SWIG_ZEND_NAMED_FE(eslevent_pushheader,_wrap_ESLevent_pushHeader,NULL)
|
||||
SWIG_ZEND_NAMED_FE(eslevent_unshiftheader,_wrap_ESLevent_unshiftHeader,NULL)
|
||||
SWIG_ZEND_NAMED_FE(eslevent_delheader,_wrap_ESLevent_delHeader,NULL)
|
||||
SWIG_ZEND_NAMED_FE(eslevent_firstheader,_wrap_ESLevent_firstHeader,NULL)
|
||||
SWIG_ZEND_NAMED_FE(eslevent_nextheader,_wrap_ESLevent_nextHeader,NULL)
|
||||
|
||||
@@ -46,6 +46,8 @@ ZEND_NAMED_FUNCTION(_wrap_ESLevent_getBody);
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_getType);
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_addBody);
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_addHeader);
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_pushHeader);
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_unshiftHeader);
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_delHeader);
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_firstHeader);
|
||||
ZEND_NAMED_FUNCTION(_wrap_ESLevent_nextHeader);
|
||||
|
||||
@@ -59,6 +59,8 @@ class ESLevent:
|
||||
def getType(*args): return apply(_ESL.ESLevent_getType, args)
|
||||
def addBody(*args): return apply(_ESL.ESLevent_addBody, args)
|
||||
def addHeader(*args): return apply(_ESL.ESLevent_addHeader, args)
|
||||
def pushHeader(*args): return apply(_ESL.ESLevent_pushHeader, args)
|
||||
def unshiftHeader(*args): return apply(_ESL.ESLevent_unshiftHeader, args)
|
||||
def delHeader(*args): return apply(_ESL.ESLevent_delHeader, args)
|
||||
def firstHeader(*args): return apply(_ESL.ESLevent_firstHeader, args)
|
||||
def nextHeader(*args): return apply(_ESL.ESLevent_nextHeader, args)
|
||||
|
||||
@@ -3373,17 +3373,21 @@ SWIGINTERN PyObject *_wrap_ESLevent_getHeader(PyObject *SWIGUNUSEDPARM(self), Py
|
||||
PyObject *resultobj = 0;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
int arg3 = (int) -1 ;
|
||||
char *result = 0 ;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int val3 ;
|
||||
int ecode3 = 0 ;
|
||||
PyObject * obj0 = 0 ;
|
||||
PyObject * obj1 = 0 ;
|
||||
PyObject * obj2 = 0 ;
|
||||
|
||||
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
|
||||
if (!PyArg_ParseTuple(args,(char *)"OO:ESLevent_getHeader",&obj0,&obj1)) SWIG_fail;
|
||||
if (!PyArg_ParseTuple(args,(char *)"OO|O:ESLevent_getHeader",&obj0,&obj1,&obj2)) SWIG_fail;
|
||||
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
if (!SWIG_IsOK(res1)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_getHeader" "', argument " "1"" of type '" "ESLevent *""'");
|
||||
@@ -3394,9 +3398,16 @@ SWIGINTERN PyObject *_wrap_ESLevent_getHeader(PyObject *SWIGUNUSEDPARM(self), Py
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_getHeader" "', argument " "2"" of type '" "char const *""'");
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
if (obj2) {
|
||||
ecode3 = SWIG_AsVal_int(obj2, &val3);
|
||||
if (!SWIG_IsOK(ecode3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ESLevent_getHeader" "', argument " "3"" of type '" "int""'");
|
||||
}
|
||||
arg3 = static_cast< int >(val3);
|
||||
}
|
||||
{
|
||||
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2);
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2,arg3);
|
||||
SWIG_PYTHON_THREAD_END_ALLOW;
|
||||
}
|
||||
resultobj = SWIG_FromCharPtr((const char *)result);
|
||||
@@ -3562,6 +3573,112 @@ fail:
|
||||
}
|
||||
|
||||
|
||||
SWIGINTERN PyObject *_wrap_ESLevent_pushHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
|
||||
PyObject *resultobj = 0;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int res3 ;
|
||||
char *buf3 = 0 ;
|
||||
int alloc3 = 0 ;
|
||||
PyObject * obj0 = 0 ;
|
||||
PyObject * obj1 = 0 ;
|
||||
PyObject * obj2 = 0 ;
|
||||
|
||||
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
|
||||
if (!PyArg_ParseTuple(args,(char *)"OOO:ESLevent_pushHeader",&obj0,&obj1,&obj2)) SWIG_fail;
|
||||
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
if (!SWIG_IsOK(res1)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_pushHeader" "', argument " "1"" of type '" "ESLevent *""'");
|
||||
}
|
||||
arg1 = reinterpret_cast< ESLevent * >(argp1);
|
||||
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
|
||||
if (!SWIG_IsOK(res2)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_pushHeader" "', argument " "2"" of type '" "char const *""'");
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
|
||||
if (!SWIG_IsOK(res3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ESLevent_pushHeader" "', argument " "3"" of type '" "char const *""'");
|
||||
}
|
||||
arg3 = reinterpret_cast< char * >(buf3);
|
||||
{
|
||||
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
|
||||
result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3);
|
||||
SWIG_PYTHON_THREAD_END_ALLOW;
|
||||
}
|
||||
resultobj = SWIG_From_bool(static_cast< bool >(result));
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
SWIG_PYTHON_THREAD_END_BLOCK;
|
||||
return resultobj;
|
||||
fail:
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
SWIG_PYTHON_THREAD_END_BLOCK;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
SWIGINTERN PyObject *_wrap_ESLevent_unshiftHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
|
||||
PyObject *resultobj = 0;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int res3 ;
|
||||
char *buf3 = 0 ;
|
||||
int alloc3 = 0 ;
|
||||
PyObject * obj0 = 0 ;
|
||||
PyObject * obj1 = 0 ;
|
||||
PyObject * obj2 = 0 ;
|
||||
|
||||
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
|
||||
if (!PyArg_ParseTuple(args,(char *)"OOO:ESLevent_unshiftHeader",&obj0,&obj1,&obj2)) SWIG_fail;
|
||||
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
if (!SWIG_IsOK(res1)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ESLevent_unshiftHeader" "', argument " "1"" of type '" "ESLevent *""'");
|
||||
}
|
||||
arg1 = reinterpret_cast< ESLevent * >(argp1);
|
||||
res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
|
||||
if (!SWIG_IsOK(res2)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ESLevent_unshiftHeader" "', argument " "2"" of type '" "char const *""'");
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
|
||||
if (!SWIG_IsOK(res3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "ESLevent_unshiftHeader" "', argument " "3"" of type '" "char const *""'");
|
||||
}
|
||||
arg3 = reinterpret_cast< char * >(buf3);
|
||||
{
|
||||
SWIG_PYTHON_THREAD_BEGIN_ALLOW;
|
||||
result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3);
|
||||
SWIG_PYTHON_THREAD_END_ALLOW;
|
||||
}
|
||||
resultobj = SWIG_From_bool(static_cast< bool >(result));
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
SWIG_PYTHON_THREAD_END_BLOCK;
|
||||
return resultobj;
|
||||
fail:
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
SWIG_PYTHON_THREAD_END_BLOCK;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
SWIGINTERN PyObject *_wrap_ESLevent_delHeader(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
|
||||
PyObject *resultobj = 0;
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
@@ -4726,6 +4843,8 @@ static PyMethodDef SwigMethods[] = {
|
||||
{ (char *)"ESLevent_getType", _wrap_ESLevent_getType, METH_VARARGS, NULL},
|
||||
{ (char *)"ESLevent_addBody", _wrap_ESLevent_addBody, METH_VARARGS, NULL},
|
||||
{ (char *)"ESLevent_addHeader", _wrap_ESLevent_addHeader, METH_VARARGS, NULL},
|
||||
{ (char *)"ESLevent_pushHeader", _wrap_ESLevent_pushHeader, METH_VARARGS, NULL},
|
||||
{ (char *)"ESLevent_unshiftHeader", _wrap_ESLevent_unshiftHeader, METH_VARARGS, NULL},
|
||||
{ (char *)"ESLevent_delHeader", _wrap_ESLevent_delHeader, METH_VARARGS, NULL},
|
||||
{ (char *)"ESLevent_firstHeader", _wrap_ESLevent_firstHeader, METH_VARARGS, NULL},
|
||||
{ (char *)"ESLevent_nextHeader", _wrap_ESLevent_nextHeader, METH_VARARGS, NULL},
|
||||
|
||||
+106
-2
@@ -2396,15 +2396,18 @@ SWIGINTERN VALUE
|
||||
_wrap_ESLevent_getHeader(int argc, VALUE *argv, VALUE self) {
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
int arg3 = (int) -1 ;
|
||||
char *result = 0 ;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int val3 ;
|
||||
int ecode3 = 0 ;
|
||||
VALUE vresult = Qnil;
|
||||
|
||||
if ((argc < 1) || (argc > 1)) {
|
||||
if ((argc < 1) || (argc > 2)) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
|
||||
}
|
||||
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
@@ -2417,7 +2420,14 @@ _wrap_ESLevent_getHeader(int argc, VALUE *argv, VALUE self) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","getHeader", 2, argv[0] ));
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2);
|
||||
if (argc > 1) {
|
||||
ecode3 = SWIG_AsVal_int(argv[1], &val3);
|
||||
if (!SWIG_IsOK(ecode3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","getHeader", 3, argv[1] ));
|
||||
}
|
||||
arg3 = static_cast< int >(val3);
|
||||
}
|
||||
result = (char *)(arg1)->getHeader((char const *)arg2,arg3);
|
||||
vresult = SWIG_FromCharPtr((const char *)result);
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
return vresult;
|
||||
@@ -2556,6 +2566,98 @@ fail:
|
||||
}
|
||||
|
||||
|
||||
SWIGINTERN VALUE
|
||||
_wrap_ESLevent_pushHeader(int argc, VALUE *argv, VALUE self) {
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int res3 ;
|
||||
char *buf3 = 0 ;
|
||||
int alloc3 = 0 ;
|
||||
VALUE vresult = Qnil;
|
||||
|
||||
if ((argc < 2) || (argc > 2)) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
||||
}
|
||||
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
if (!SWIG_IsOK(res1)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ESLevent *","pushHeader", 1, self ));
|
||||
}
|
||||
arg1 = reinterpret_cast< ESLevent * >(argp1);
|
||||
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
|
||||
if (!SWIG_IsOK(res2)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","pushHeader", 2, argv[0] ));
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
|
||||
if (!SWIG_IsOK(res3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","pushHeader", 3, argv[1] ));
|
||||
}
|
||||
arg3 = reinterpret_cast< char * >(buf3);
|
||||
result = (bool)(arg1)->pushHeader((char const *)arg2,(char const *)arg3);
|
||||
vresult = SWIG_From_bool(static_cast< bool >(result));
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
return vresult;
|
||||
fail:
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
|
||||
SWIGINTERN VALUE
|
||||
_wrap_ESLevent_unshiftHeader(int argc, VALUE *argv, VALUE self) {
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
char *arg2 = (char *) 0 ;
|
||||
char *arg3 = (char *) 0 ;
|
||||
bool result;
|
||||
void *argp1 = 0 ;
|
||||
int res1 = 0 ;
|
||||
int res2 ;
|
||||
char *buf2 = 0 ;
|
||||
int alloc2 = 0 ;
|
||||
int res3 ;
|
||||
char *buf3 = 0 ;
|
||||
int alloc3 = 0 ;
|
||||
VALUE vresult = Qnil;
|
||||
|
||||
if ((argc < 2) || (argc > 2)) {
|
||||
rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
|
||||
}
|
||||
res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_ESLevent, 0 | 0 );
|
||||
if (!SWIG_IsOK(res1)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ESLevent *","unshiftHeader", 1, self ));
|
||||
}
|
||||
arg1 = reinterpret_cast< ESLevent * >(argp1);
|
||||
res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
|
||||
if (!SWIG_IsOK(res2)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","unshiftHeader", 2, argv[0] ));
|
||||
}
|
||||
arg2 = reinterpret_cast< char * >(buf2);
|
||||
res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
|
||||
if (!SWIG_IsOK(res3)) {
|
||||
SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","unshiftHeader", 3, argv[1] ));
|
||||
}
|
||||
arg3 = reinterpret_cast< char * >(buf3);
|
||||
result = (bool)(arg1)->unshiftHeader((char const *)arg2,(char const *)arg3);
|
||||
vresult = SWIG_From_bool(static_cast< bool >(result));
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
return vresult;
|
||||
fail:
|
||||
if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
|
||||
if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
|
||||
return Qnil;
|
||||
}
|
||||
|
||||
|
||||
SWIGINTERN VALUE
|
||||
_wrap_ESLevent_delHeader(int argc, VALUE *argv, VALUE self) {
|
||||
ESLevent *arg1 = (ESLevent *) 0 ;
|
||||
@@ -3835,6 +3937,8 @@ SWIGEXPORT void Init_ESL(void) {
|
||||
rb_define_method(cESLevent.klass, "getType", VALUEFUNC(_wrap_ESLevent_getType), -1);
|
||||
rb_define_method(cESLevent.klass, "addBody", VALUEFUNC(_wrap_ESLevent_addBody), -1);
|
||||
rb_define_method(cESLevent.klass, "addHeader", VALUEFUNC(_wrap_ESLevent_addHeader), -1);
|
||||
rb_define_method(cESLevent.klass, "pushHeader", VALUEFUNC(_wrap_ESLevent_pushHeader), -1);
|
||||
rb_define_method(cESLevent.klass, "unshiftHeader", VALUEFUNC(_wrap_ESLevent_unshiftHeader), -1);
|
||||
rb_define_method(cESLevent.klass, "delHeader", VALUEFUNC(_wrap_ESLevent_delHeader), -1);
|
||||
rb_define_method(cESLevent.klass, "firstHeader", VALUEFUNC(_wrap_ESLevent_firstHeader), -1);
|
||||
rb_define_method(cESLevent.klass, "nextHeader", VALUEFUNC(_wrap_ESLevent_nextHeader), -1);
|
||||
|
||||
+29
-2
@@ -1088,7 +1088,11 @@ ESL_DECLARE(esl_status_t) esl_recv_event(esl_handle_t *handle, int check_q, esl_
|
||||
if (hname && hval) {
|
||||
esl_url_decode(hval);
|
||||
esl_log(ESL_LOG_DEBUG, "RECV HEADER [%s] = [%s]\n", hname, hval);
|
||||
esl_event_add_header_string(revent, ESL_STACK_BOTTOM, hname, hval);
|
||||
if (!strncmp(hval, "ARRAY::", 7)) {
|
||||
esl_event_add_array(revent, hname, hval);
|
||||
} else {
|
||||
esl_event_add_header_string(revent, ESL_STACK_BOTTOM, hname, hval);
|
||||
}
|
||||
}
|
||||
|
||||
p = e;
|
||||
@@ -1217,7 +1221,12 @@ ESL_DECLARE(esl_status_t) esl_recv_event(esl_handle_t *handle, int check_q, esl_
|
||||
esl_event_del_header(handle->last_ievent, "event-name");
|
||||
esl_name_event(hval, &handle->last_ievent->event_id);
|
||||
}
|
||||
esl_event_add_header_string(handle->last_ievent, ESL_STACK_BOTTOM, hname, hval);
|
||||
|
||||
if (!strncmp(hval, "ARRAY::", 7)) {
|
||||
esl_event_add_array(handle->last_ievent, hname, hval);
|
||||
} else {
|
||||
esl_event_add_header_string(handle->last_ievent, ESL_STACK_BOTTOM, hname, hval);
|
||||
}
|
||||
}
|
||||
|
||||
beg = c + 1;
|
||||
@@ -1371,5 +1380,23 @@ ESL_DECLARE(esl_status_t) esl_send_recv_timed(esl_handle_t *handle, const char *
|
||||
}
|
||||
|
||||
|
||||
ESL_DECLARE(unsigned int) esl_separate_string_string(char *buf, const char *delim, char **array, unsigned int arraylen)
|
||||
{
|
||||
unsigned int count = 0;
|
||||
char *d;
|
||||
size_t dlen = strlen(delim);
|
||||
|
||||
array[count++] = buf;
|
||||
|
||||
while (count < arraylen && array[count - 1]) {
|
||||
if ((d = strstr(array[count - 1], delim))) {
|
||||
*d = '\0';
|
||||
d += dlen;
|
||||
array[count++] = d;
|
||||
} else
|
||||
break;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
+469
-160
@@ -235,8 +235,7 @@ static unsigned int esl_ci_hashfunc_default(const char *char_key, esl_ssize_t *k
|
||||
return hash;
|
||||
}
|
||||
|
||||
|
||||
ESL_DECLARE(char *)esl_event_get_header(esl_event_t *event, const char *header_name)
|
||||
ESL_DECLARE(esl_event_header_t *) esl_event_get_header_ptr(esl_event_t *event, const char *header_name)
|
||||
{
|
||||
esl_event_header_t *hp;
|
||||
esl_ssize_t hlen = -1;
|
||||
@@ -244,18 +243,39 @@ ESL_DECLARE(char *)esl_event_get_header(esl_event_t *event, const char *header_n
|
||||
|
||||
esl_assert(event);
|
||||
|
||||
if (!header_name) return NULL;
|
||||
|
||||
if (!header_name)
|
||||
return NULL;
|
||||
|
||||
hash = esl_ci_hashfunc_default(header_name, &hlen);
|
||||
|
||||
|
||||
for (hp = event->headers; hp; hp = hp->next) {
|
||||
if ((!hp->hash || hash == hp->hash) && !strcasecmp(hp->name, header_name) ) {
|
||||
return hp->value;
|
||||
if ((!hp->hash || hash == hp->hash) && !strcasecmp(hp->name, header_name)) {
|
||||
return hp;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ESL_DECLARE(char *) esl_event_get_header_idx(esl_event_t *event, const char *header_name, int idx)
|
||||
{
|
||||
esl_event_header_t *hp;
|
||||
|
||||
if ((hp = esl_event_get_header_ptr(event, header_name))) {
|
||||
if (idx > -1) {
|
||||
if (idx < hp->idx) {
|
||||
return hp->array[idx];
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return hp->value;
|
||||
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ESL_DECLARE(char *)esl_event_get_body(esl_event_t *event)
|
||||
{
|
||||
return (event ? event->body : NULL);
|
||||
@@ -264,7 +284,7 @@ ESL_DECLARE(char *)esl_event_get_body(esl_event_t *event)
|
||||
ESL_DECLARE(esl_status_t) esl_event_del_header_val(esl_event_t *event, const char *header_name, const char *val)
|
||||
{
|
||||
esl_event_header_t *hp, *lp = NULL, *tp;
|
||||
esl_status_t status = ESL_FAIL;
|
||||
esl_status_t status = ESL_FALSE;
|
||||
int x = 0;
|
||||
esl_ssize_t hlen = -1;
|
||||
unsigned long hash = 0;
|
||||
@@ -273,12 +293,12 @@ ESL_DECLARE(esl_status_t) esl_event_del_header_val(esl_event_t *event, const cha
|
||||
while (tp) {
|
||||
hp = tp;
|
||||
tp = tp->next;
|
||||
|
||||
|
||||
x++;
|
||||
esl_assert(x < 1000);
|
||||
esl_assert(x < 1000000);
|
||||
hash = esl_ci_hashfunc_default(header_name, &hlen);
|
||||
|
||||
if (hp->name && (!hp->hash || hash == hp->hash) && !strcasecmp(header_name, hp->name) && (esl_strlen_zero(val) || !strcmp(hp->value, val))) {
|
||||
if ((!hp->hash || hash == hp->hash) && (hp->name && !strcasecmp(header_name, hp->name)) && (esl_strlen_zero(val) || !strcmp(hp->value, val))) {
|
||||
if (lp) {
|
||||
lp->next = hp->next;
|
||||
} else {
|
||||
@@ -288,10 +308,27 @@ ESL_DECLARE(esl_status_t) esl_event_del_header_val(esl_event_t *event, const cha
|
||||
event->last_header = lp;
|
||||
}
|
||||
FREE(hp->name);
|
||||
FREE(hp->value);
|
||||
memset(hp, 0, sizeof(*hp));
|
||||
FREE(hp);
|
||||
|
||||
if (hp->idx) {
|
||||
int i = 0;
|
||||
hp->value = NULL;
|
||||
|
||||
for (i = 0; i < hp->idx; i++) {
|
||||
FREE(hp->array[i]);
|
||||
}
|
||||
FREE(hp->array);
|
||||
}
|
||||
|
||||
FREE(hp->value);
|
||||
|
||||
memset(hp, 0, sizeof(*hp));
|
||||
#ifdef ESL_EVENT_RECYCLE
|
||||
if (esl_queue_trypush(EVENT_HEADER_RECYCLE_QUEUE, hp) != ESL_SUCCESS) {
|
||||
FREE(hp);
|
||||
}
|
||||
#else
|
||||
FREE(hp);
|
||||
#endif
|
||||
status = ESL_SUCCESS;
|
||||
} else {
|
||||
lp = hp;
|
||||
@@ -301,40 +338,245 @@ ESL_DECLARE(esl_status_t) esl_event_del_header_val(esl_event_t *event, const cha
|
||||
return status;
|
||||
}
|
||||
|
||||
static esl_status_t esl_event_base_add_header(esl_event_t *event, esl_stack_t stack, const char *header_name, char *data)
|
||||
static esl_event_header_t *new_header(const char *header_name)
|
||||
{
|
||||
esl_event_header_t *header;
|
||||
esl_ssize_t hlen = -1;
|
||||
|
||||
header = ALLOC(sizeof(*header));
|
||||
esl_assert(header);
|
||||
|
||||
if ((event->flags & ESL_UNIQ_HEADERS)) {
|
||||
esl_event_del_header(event, header_name);
|
||||
#ifdef ESL_EVENT_RECYCLE
|
||||
void *pop;
|
||||
if (esl_queue_trypop(EVENT_HEADER_RECYCLE_QUEUE, &pop) == ESL_SUCCESS) {
|
||||
header = (esl_event_header_t *) pop;
|
||||
} else {
|
||||
#endif
|
||||
header = ALLOC(sizeof(*header));
|
||||
esl_assert(header);
|
||||
#ifdef ESL_EVENT_RECYCLE
|
||||
}
|
||||
#endif
|
||||
|
||||
memset(header, 0, sizeof(*header));
|
||||
header->name = DUP(header_name);
|
||||
|
||||
return header;
|
||||
|
||||
}
|
||||
|
||||
ESL_DECLARE(int) esl_event_add_array(esl_event_t *event, const char *var, const char *val)
|
||||
{
|
||||
char *data;
|
||||
char **array;
|
||||
int max = 0;
|
||||
int len;
|
||||
const char *p;
|
||||
int i;
|
||||
|
||||
if (strlen(val) < 8) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
memset(header, 0, sizeof(*header));
|
||||
p = val + 7;
|
||||
|
||||
header->name = DUP(header_name);
|
||||
header->value = data;
|
||||
header->hash = esl_ci_hashfunc_default(header->name, &hlen);
|
||||
max = 1;
|
||||
|
||||
while((p = strstr(p, "|:"))) {
|
||||
max++;
|
||||
p += 2;
|
||||
}
|
||||
|
||||
if (!max) {
|
||||
return -2;
|
||||
}
|
||||
|
||||
data = strdup(val + 7);
|
||||
|
||||
if (stack == ESL_STACK_TOP) {
|
||||
header->next = event->headers;
|
||||
event->headers = header;
|
||||
if (!event->last_header) {
|
||||
len = (sizeof(char *) * max) + 1;
|
||||
array = malloc(len);
|
||||
esl_assert(array);
|
||||
memset(array, 0, len);
|
||||
|
||||
esl_separate_string_string(data, "|:", array, max);
|
||||
|
||||
for(i = 0; i < max; i++) {
|
||||
esl_event_add_header_string(event, ESL_STACK_PUSH, var, array[i]);
|
||||
}
|
||||
|
||||
free(array);
|
||||
free(data);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static esl_status_t esl_event_base_add_header(esl_event_t *event, esl_stack_t stack, const char *header_name, char *data)
|
||||
{
|
||||
esl_event_header_t *header = NULL;
|
||||
esl_ssize_t hlen = -1;
|
||||
int exists = 0, fly = 0;
|
||||
char *index_ptr;
|
||||
int index = 0;
|
||||
char *real_header_name = NULL;
|
||||
|
||||
if ((index_ptr = strchr(header_name, '['))) {
|
||||
index_ptr++;
|
||||
index = atoi(index_ptr);
|
||||
real_header_name = DUP(header_name);
|
||||
if ((index_ptr = strchr(real_header_name, '['))) {
|
||||
*index_ptr++ = '\0';
|
||||
}
|
||||
header_name = real_header_name;
|
||||
}
|
||||
|
||||
if (index_ptr || (stack & ESL_STACK_PUSH) || (stack & ESL_STACK_UNSHIFT)) {
|
||||
|
||||
if (!(header = esl_event_get_header_ptr(event, header_name)) && index_ptr) {
|
||||
|
||||
header = new_header(header_name);
|
||||
|
||||
if (esl_test_flag(event, ESL_EF_UNIQ_HEADERS)) {
|
||||
esl_event_del_header(event, header_name);
|
||||
}
|
||||
|
||||
fly++;
|
||||
}
|
||||
|
||||
if ((header = esl_event_get_header_ptr(event, header_name))) {
|
||||
|
||||
if (index_ptr) {
|
||||
if (index > -1 && index <= 4000) {
|
||||
if (index < header->idx) {
|
||||
FREE(header->array[index]);
|
||||
header->array[index] = DUP(data);
|
||||
} else {
|
||||
int i;
|
||||
char **m;
|
||||
|
||||
m = realloc(header->array, sizeof(char *) * (index + 1));
|
||||
esl_assert(m);
|
||||
header->array = m;
|
||||
for (i = header->idx; i < index; i++) {
|
||||
m[i] = DUP("");
|
||||
}
|
||||
m[index] = DUP(data);
|
||||
header->idx = index + 1;
|
||||
if (!fly) {
|
||||
exists = 1;
|
||||
}
|
||||
|
||||
goto redraw;
|
||||
}
|
||||
}
|
||||
goto end;
|
||||
} else {
|
||||
if ((stack & ESL_STACK_PUSH) || (stack & ESL_STACK_UNSHIFT)) {
|
||||
exists++;
|
||||
stack &= ~(ESL_STACK_TOP | ESL_STACK_BOTTOM);
|
||||
} else {
|
||||
header = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (!header) {
|
||||
|
||||
if (esl_strlen_zero(data)) {
|
||||
esl_event_del_header(event, header_name);
|
||||
FREE(data);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (esl_test_flag(event, ESL_EF_UNIQ_HEADERS)) {
|
||||
esl_event_del_header(event, header_name);
|
||||
}
|
||||
|
||||
if (strstr(data, "ARRAY::")) {
|
||||
esl_event_add_array(event, header_name, data);
|
||||
FREE(data);
|
||||
goto end;
|
||||
}
|
||||
|
||||
|
||||
header = new_header(header_name);
|
||||
}
|
||||
|
||||
if ((stack & ESL_STACK_PUSH) || (stack & ESL_STACK_UNSHIFT)) {
|
||||
char **m = NULL;
|
||||
esl_size_t len = 0;
|
||||
char *hv;
|
||||
int i = 0, j = 0;
|
||||
|
||||
if (header->value && !header->idx) {
|
||||
m = malloc(sizeof(char *));
|
||||
esl_assert(m);
|
||||
m[0] = header->value;
|
||||
header->value = NULL;
|
||||
header->array = m;
|
||||
header->idx++;
|
||||
m = NULL;
|
||||
}
|
||||
|
||||
i = header->idx + 1;
|
||||
m = realloc(header->array, sizeof(char *) * i);
|
||||
esl_assert(m);
|
||||
|
||||
if ((stack & ESL_STACK_PUSH)) {
|
||||
m[header->idx] = data;
|
||||
} else if ((stack & ESL_STACK_UNSHIFT)) {
|
||||
for (j = header->idx; j > 0; j--) {
|
||||
m[j] = m[j-1];
|
||||
}
|
||||
m[0] = data;
|
||||
}
|
||||
|
||||
header->idx++;
|
||||
header->array = m;
|
||||
|
||||
redraw:
|
||||
len = 0;
|
||||
for(j = 0; j < header->idx; j++) {
|
||||
len += strlen(header->array[j]) + 2;
|
||||
}
|
||||
|
||||
if (len) {
|
||||
len += 8;
|
||||
hv = realloc(header->value, len);
|
||||
esl_assert(hv);
|
||||
header->value = hv;
|
||||
|
||||
esl_snprintf(header->value, len, "ARRAY::");
|
||||
for(j = 0; j < header->idx; j++) {
|
||||
esl_snprintf(header->value + strlen(header->value), len - strlen(header->value), "%s%s", j == 0 ? "" : "|:", header->array[j]);
|
||||
}
|
||||
}
|
||||
|
||||
} else {
|
||||
header->value = data;
|
||||
}
|
||||
|
||||
if (!exists) {
|
||||
header->hash = esl_ci_hashfunc_default(header->name, &hlen);
|
||||
|
||||
if ((stack & ESL_STACK_TOP)) {
|
||||
header->next = event->headers;
|
||||
event->headers = header;
|
||||
if (!event->last_header) {
|
||||
event->last_header = header;
|
||||
}
|
||||
} else {
|
||||
if (event->last_header) {
|
||||
event->last_header->next = header;
|
||||
} else {
|
||||
event->headers = header;
|
||||
header->next = NULL;
|
||||
}
|
||||
event->last_header = header;
|
||||
}
|
||||
} else {
|
||||
if (event->last_header) {
|
||||
event->last_header->next = header;
|
||||
} else {
|
||||
event->headers = header;
|
||||
header->next = NULL;
|
||||
}
|
||||
event->last_header = header;
|
||||
}
|
||||
|
||||
end:
|
||||
|
||||
esl_safe_free(real_header_name);
|
||||
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -386,48 +628,98 @@ ESL_DECLARE(esl_status_t) esl_event_add_body(esl_event_t *event, const char *fmt
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ESL_DECLARE(void) esl_event_destroy(esl_event_t **event)
|
||||
{
|
||||
esl_event_t *ep = *event, *this_event;
|
||||
esl_event_header_t *hp, *this_header;
|
||||
esl_event_t *ep = *event;
|
||||
esl_event_header_t *hp, *this;
|
||||
|
||||
for (ep = *event ; ep ;) {
|
||||
this_event = ep;
|
||||
ep = ep->next;
|
||||
|
||||
for (hp = this_event->headers; hp;) {
|
||||
this_header = hp;
|
||||
if (ep) {
|
||||
for (hp = ep->headers; hp;) {
|
||||
this = hp;
|
||||
hp = hp->next;
|
||||
FREE(this_header->name);
|
||||
FREE(this_header->value);
|
||||
memset(this_header, 0, sizeof(*this_header));
|
||||
FREE(this_header);
|
||||
FREE(this->name);
|
||||
|
||||
if (this->idx) {
|
||||
int i = 0;
|
||||
this->value = NULL;
|
||||
for (i = 0; i < this->idx; i++) {
|
||||
FREE(this->array[i]);
|
||||
}
|
||||
FREE(this->array);
|
||||
}
|
||||
|
||||
FREE(this->value);
|
||||
|
||||
|
||||
#ifdef ESL_EVENT_RECYCLE
|
||||
if (esl_queue_trypush(EVENT_HEADER_RECYCLE_QUEUE, this) != ESL_SUCCESS) {
|
||||
FREE(this);
|
||||
}
|
||||
#else
|
||||
FREE(this);
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
FREE(this_event->body);
|
||||
FREE(this_event->subclass_name);
|
||||
memset(this_event, 0, sizeof(*this_event));
|
||||
FREE(this_event);
|
||||
FREE(ep->body);
|
||||
FREE(ep->subclass_name);
|
||||
#ifdef ESL_EVENT_RECYCLE
|
||||
if (esl_queue_trypush(EVENT_RECYCLE_QUEUE, ep) != ESL_SUCCESS) {
|
||||
FREE(ep);
|
||||
}
|
||||
#else
|
||||
FREE(ep);
|
||||
#endif
|
||||
|
||||
}
|
||||
*event = NULL;
|
||||
}
|
||||
|
||||
ESL_DECLARE(void) esl_event_merge(esl_event_t *event, esl_event_t *tomerge)
|
||||
{
|
||||
esl_event_header_t *hp;
|
||||
|
||||
esl_assert(tomerge && event);
|
||||
|
||||
for (hp = tomerge->headers; hp; hp = hp->next) {
|
||||
if (hp->idx) {
|
||||
int i;
|
||||
|
||||
for(i = 0; i < hp->idx; i++) {
|
||||
esl_event_add_header_string(event, ESL_STACK_PUSH, hp->name, hp->array[i]);
|
||||
}
|
||||
} else {
|
||||
esl_event_add_header_string(event, ESL_STACK_BOTTOM, hp->name, hp->value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ESL_DECLARE(esl_status_t) esl_event_dup(esl_event_t **event, esl_event_t *todup)
|
||||
{
|
||||
esl_event_header_t *hp;
|
||||
|
||||
if (esl_event_create_subclass(event, ESL_EVENT_CLONE, todup->subclass_name) != ESL_SUCCESS) {
|
||||
return ESL_FAIL;
|
||||
return ESL_GENERR;
|
||||
}
|
||||
|
||||
(*event)->event_id = todup->event_id;
|
||||
|
||||
(*event)->event_user_data = todup->event_user_data;
|
||||
(*event)->bind_user_data = todup->bind_user_data;
|
||||
|
||||
(*event)->flags = todup->flags;
|
||||
for (hp = todup->headers; hp; hp = hp->next) {
|
||||
esl_event_add_header_string(*event, ESL_STACK_BOTTOM, hp->name, hp->value);
|
||||
if (todup->subclass_name && !strcmp(hp->name, "Event-Subclass")) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (hp->idx) {
|
||||
int i;
|
||||
for (i = 0; i < hp->idx; i++) {
|
||||
esl_event_add_header_string(*event, ESL_STACK_PUSH, hp->name, hp->array[i]);
|
||||
}
|
||||
} else {
|
||||
esl_event_add_header_string(*event, ESL_STACK_BOTTOM, hp->name, hp->value);
|
||||
}
|
||||
}
|
||||
|
||||
if (todup->body) {
|
||||
@@ -439,97 +731,26 @@ ESL_DECLARE(esl_status_t) esl_event_dup(esl_event_t **event, esl_event_t *todup)
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
ESL_DECLARE(esl_status_t) esl_event_create_json(esl_event_t **event, const char *json)
|
||||
{
|
||||
esl_event_t *new_event;
|
||||
cJSON *cj, *cjp;
|
||||
|
||||
|
||||
if (!(cj = cJSON_Parse(json))) {
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
if (esl_event_create(&new_event, ESL_EVENT_CLONE) != ESL_SUCCESS) {
|
||||
cJSON_Delete(cj);
|
||||
return ESL_FAIL;
|
||||
}
|
||||
|
||||
for (cjp = cj->child; cjp; cjp = cjp->next) {
|
||||
char *name = cjp->string;
|
||||
char *value = cjp->valuestring;
|
||||
|
||||
if (name && value) {
|
||||
if (!strcasecmp(name, "_body")) {
|
||||
esl_event_add_body(new_event, value);
|
||||
} else {
|
||||
if (!strcasecmp(name, "event-name")) {
|
||||
esl_event_del_header(new_event, "event-name");
|
||||
}
|
||||
|
||||
esl_name_event(value, &new_event->event_id);
|
||||
esl_event_add_header_string(new_event, ESL_STACK_BOTTOM, name, value);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
cJSON_Delete(cj);
|
||||
*event = new_event;
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
ESL_DECLARE(esl_status_t) esl_event_serialize_json(esl_event_t *event, char **str)
|
||||
{
|
||||
esl_event_header_t *hp;
|
||||
cJSON *cj;
|
||||
|
||||
*str = NULL;
|
||||
|
||||
cj = cJSON_CreateObject();
|
||||
|
||||
for (hp = event->headers; hp; hp = hp->next) {
|
||||
cJSON_AddItemToObject(cj, hp->name, cJSON_CreateString(hp->value));
|
||||
}
|
||||
if (event->body) {
|
||||
int blen = (int) strlen(event->body);
|
||||
char tmp[25];
|
||||
|
||||
esl_snprintf(tmp, sizeof(tmp), "%d", blen);
|
||||
|
||||
cJSON_AddItemToObject(cj, "Content-Length", cJSON_CreateString(tmp));
|
||||
cJSON_AddItemToObject(cj, "_body", cJSON_CreateString(event->body));
|
||||
}
|
||||
|
||||
*str = cJSON_Print(cj);
|
||||
cJSON_Delete(cj);
|
||||
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
ESL_DECLARE(esl_status_t) esl_event_serialize(esl_event_t *event, char **str, esl_bool_t encode)
|
||||
{
|
||||
size_t len = 0;
|
||||
esl_size_t len = 0;
|
||||
esl_event_header_t *hp;
|
||||
size_t llen = 0, dlen = 0, blocksize = 512, encode_len = 1536, new_len = 0;
|
||||
esl_size_t llen = 0, dlen = 0, blocksize = 512, encode_len = 1536, new_len = 0;
|
||||
char *buf;
|
||||
char *encode_buf = NULL; /* used for url encoding of variables to make sure unsafe things stay out of the serialized copy */
|
||||
int clen = 0;
|
||||
|
||||
if (!event || !event->headers)
|
||||
return ESL_FAIL;
|
||||
|
||||
*str = NULL;
|
||||
|
||||
dlen = blocksize * 2;
|
||||
|
||||
if (!(buf = malloc(dlen))) {
|
||||
return ESL_FAIL;
|
||||
abort();
|
||||
}
|
||||
|
||||
/* go ahead and give ourselves some space to work with, should save a few reallocs */
|
||||
if (!(encode_buf = malloc(encode_len))) {
|
||||
esl_safe_free(buf);
|
||||
return ESL_FAIL;
|
||||
abort();
|
||||
}
|
||||
|
||||
/* esl_log_printf(ESL_CHANNEL_LOG, ESL_LOG_INFO, "hit serialized!.\n"); */
|
||||
@@ -542,54 +763,54 @@ ESL_DECLARE(esl_status_t) esl_event_serialize(esl_event_t *event, char **str, es
|
||||
* destroying loop.
|
||||
*/
|
||||
|
||||
if (!strcasecmp(hp->name, "content-length")) {
|
||||
clen++;
|
||||
if (hp->idx) {
|
||||
int i;
|
||||
new_len = 0;
|
||||
for(i = 0; i < hp->idx; i++) {
|
||||
new_len += (strlen(hp->array[i]) * 3) + 1;
|
||||
}
|
||||
} else {
|
||||
new_len = (strlen(hp->value) * 3) + 1;
|
||||
}
|
||||
|
||||
|
||||
new_len = (strlen(hp->value) * 3) + 1;
|
||||
|
||||
if (encode_len < new_len) {
|
||||
char *tmp;
|
||||
/* esl_log_printf(ESL_CHANNEL_LOG, ESL_LOG_INFO, "Allocing %d was %d.\n", ((strlen(hp->value) * 3) + 1), encode_len); */
|
||||
/* we can use realloc for initial alloc as well, if encode_buf is zero it treats it as a malloc */
|
||||
|
||||
/* keep track of the size of our allocation */
|
||||
encode_len = new_len;
|
||||
|
||||
if (!(tmp = realloc(encode_buf, encode_len))) {
|
||||
/* oh boy, ram's gone, give back what little we grabbed and bail */
|
||||
esl_safe_free(buf);
|
||||
esl_safe_free(encode_buf);
|
||||
return ESL_FAIL;
|
||||
abort();
|
||||
}
|
||||
|
||||
encode_buf = tmp;
|
||||
}
|
||||
|
||||
/* handle any bad things in the string like newlines : etc that screw up the serialized format */
|
||||
|
||||
|
||||
if (encode) {
|
||||
esl_url_encode(hp->value, encode_buf, encode_len);
|
||||
} else {
|
||||
esl_snprintf(encode_buf, encode_len, "%s", hp->value);
|
||||
esl_snprintf(encode_buf, encode_len, "[%s]", hp->value);
|
||||
}
|
||||
|
||||
|
||||
llen = strlen(hp->name) + strlen(encode_buf) + 8;
|
||||
|
||||
if ((len + llen) > dlen) {
|
||||
char *m;
|
||||
char *old = buf;
|
||||
dlen += (blocksize + (len + llen));
|
||||
if ((m = realloc(buf, dlen))) {
|
||||
buf = m;
|
||||
} else {
|
||||
/* we seem to be out of memory trying to resize the serialize string, give back what we already have and give up */
|
||||
esl_safe_free(buf);
|
||||
esl_safe_free(encode_buf);
|
||||
return ESL_FAIL;
|
||||
buf = old;
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
snprintf(buf + len, dlen - len, "%s: %s\n", hp->name, *encode_buf == '\0' ? "_undef_" : encode_buf);
|
||||
esl_snprintf(buf + len, dlen - len, "%s: %s\n", hp->name, *encode_buf == '\0' ? "_undef_" : encode_buf);
|
||||
len = strlen(buf);
|
||||
}
|
||||
|
||||
@@ -608,33 +829,121 @@ ESL_DECLARE(esl_status_t) esl_event_serialize(esl_event_t *event, char **str, es
|
||||
|
||||
if ((len + llen) > dlen) {
|
||||
char *m;
|
||||
char *old = buf;
|
||||
dlen += (blocksize + (len + llen));
|
||||
if ((m = realloc(buf, dlen))) {
|
||||
buf = m;
|
||||
} else {
|
||||
esl_safe_free(buf);
|
||||
return ESL_FAIL;
|
||||
buf = old;
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (blen) {
|
||||
if (clen) {
|
||||
snprintf(buf + len, dlen - len, "\n%s", event->body);
|
||||
} else {
|
||||
snprintf(buf + len, dlen - len, "Content-Length: %d\n\n%s", (int)strlen(event->body), event->body);
|
||||
|
||||
}
|
||||
esl_snprintf(buf + len, dlen - len, "Content-Length: %d\n\n%s", blen, event->body);
|
||||
} else {
|
||||
esl_snprintf(buf + len, dlen - len, "\n");
|
||||
}
|
||||
} else {
|
||||
snprintf(buf + len, dlen - len, "\n");
|
||||
esl_snprintf(buf + len, dlen - len, "\n");
|
||||
}
|
||||
|
||||
|
||||
*str = buf;
|
||||
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
ESL_DECLARE(esl_status_t) esl_event_create_json(esl_event_t **event, const char *json)
|
||||
{
|
||||
esl_event_t *new_event;
|
||||
cJSON *cj, *cjp;
|
||||
|
||||
|
||||
if (!(cj = cJSON_Parse(json))) {
|
||||
return ESL_FALSE;
|
||||
}
|
||||
|
||||
if (esl_event_create(&new_event, ESL_EVENT_CLONE) != ESL_SUCCESS) {
|
||||
cJSON_Delete(cj);
|
||||
return ESL_FALSE;
|
||||
}
|
||||
|
||||
for (cjp = cj->child; cjp; cjp = cjp->next) {
|
||||
char *name = cjp->string;
|
||||
char *value = cjp->valuestring;
|
||||
|
||||
if (name && value) {
|
||||
if (!strcasecmp(name, "_body")) {
|
||||
esl_event_add_body(new_event, value, ESL_VA_NONE);
|
||||
} else {
|
||||
if (!strcasecmp(name, "event-name")) {
|
||||
esl_event_del_header(new_event, "event-name");
|
||||
esl_name_event(value, &new_event->event_id);
|
||||
}
|
||||
|
||||
esl_event_add_header_string(new_event, ESL_STACK_BOTTOM, name, value);
|
||||
}
|
||||
|
||||
} else if (name) {
|
||||
if (cjp->type == cJSON_Array) {
|
||||
int i, x = cJSON_GetArraySize(cjp);
|
||||
|
||||
for (i = 0; i < x; i++) {
|
||||
cJSON *item = cJSON_GetArrayItem(cjp, i);
|
||||
|
||||
if (item != NULL && item->type == cJSON_String && item->valuestring) {
|
||||
esl_event_add_header_string(new_event, ESL_STACK_PUSH, name, item->valuestring);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cJSON_Delete(cj);
|
||||
*event = new_event;
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
ESL_DECLARE(esl_status_t) esl_event_serialize_json(esl_event_t *event, char **str)
|
||||
{
|
||||
esl_event_header_t *hp;
|
||||
cJSON *cj;
|
||||
|
||||
*str = NULL;
|
||||
|
||||
cj = cJSON_CreateObject();
|
||||
|
||||
for (hp = event->headers; hp; hp = hp->next) {
|
||||
if (hp->idx) {
|
||||
cJSON *a = cJSON_CreateArray();
|
||||
int i;
|
||||
|
||||
for(i = 0; i < hp->idx; i++) {
|
||||
cJSON_AddItemToArray(a, cJSON_CreateString(hp->array[i]));
|
||||
}
|
||||
|
||||
cJSON_AddItemToObject(cj, hp->name, a);
|
||||
|
||||
} else {
|
||||
cJSON_AddItemToObject(cj, hp->name, cJSON_CreateString(hp->value));
|
||||
}
|
||||
}
|
||||
|
||||
if (event->body) {
|
||||
int blen = (int) strlen(event->body);
|
||||
char tmp[25];
|
||||
|
||||
esl_snprintf(tmp, sizeof(tmp), "%d", blen);
|
||||
|
||||
cJSON_AddItemToObject(cj, "Content-Length", cJSON_CreateString(tmp));
|
||||
cJSON_AddItemToObject(cj, "_body", cJSON_CreateString(event->body));
|
||||
}
|
||||
|
||||
*str = cJSON_Print(cj);
|
||||
cJSON_Delete(cj);
|
||||
|
||||
return ESL_SUCCESS;
|
||||
}
|
||||
|
||||
/* For Emacs:
|
||||
* Local Variables:
|
||||
|
||||
@@ -390,12 +390,12 @@ bool ESLevent::setPriority(esl_priority_t priority)
|
||||
return false;
|
||||
}
|
||||
|
||||
const char *ESLevent::getHeader(const char *header_name)
|
||||
const char *ESLevent::getHeader(const char *header_name, int idx)
|
||||
{
|
||||
this_check("");
|
||||
|
||||
if (event) {
|
||||
return esl_event_get_header(event, header_name);
|
||||
return esl_event_get_header_idx(event, header_name, idx);
|
||||
} else {
|
||||
esl_log(ESL_LOG_ERROR, "Trying to getHeader an event that does not exist!\n");
|
||||
}
|
||||
@@ -415,6 +415,32 @@ bool ESLevent::addHeader(const char *header_name, const char *value)
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ESLevent::pushHeader(const char *header_name, const char *value)
|
||||
{
|
||||
this_check(false);
|
||||
|
||||
if (event) {
|
||||
return esl_event_add_header_string(event, ESL_STACK_PUSH, header_name, value) == ESL_SUCCESS ? true : false;
|
||||
} else {
|
||||
esl_log(ESL_LOG_ERROR, "Trying to addHeader an event that does not exist!\n");
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ESLevent::unshiftHeader(const char *header_name, const char *value)
|
||||
{
|
||||
this_check(false);
|
||||
|
||||
if (event) {
|
||||
return esl_event_add_header_string(event, ESL_STACK_UNSHIFT, header_name, value) == ESL_SUCCESS ? true : false;
|
||||
} else {
|
||||
esl_log(ESL_LOG_ERROR, "Trying to addHeader an event that does not exist!\n");
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
bool ESLevent::delHeader(const char *header_name)
|
||||
{
|
||||
this_check(false);
|
||||
|
||||
@@ -42,6 +42,7 @@ extern "C" {
|
||||
|
||||
#define esl_copy_string(_x, _y, _z) strncpy(_x, _y, _z - 1)
|
||||
#define esl_set_string(_x, _y) esl_copy_string(_x, _y, sizeof(_x))
|
||||
#define ESL_VA_NONE "%s", ""
|
||||
|
||||
typedef struct esl_event_header esl_event_header_t;
|
||||
typedef struct esl_event esl_event_t;
|
||||
@@ -262,7 +263,8 @@ typedef enum {
|
||||
ESL_SUCCESS,
|
||||
ESL_FAIL,
|
||||
ESL_BREAK,
|
||||
ESL_DISCONNECTED
|
||||
ESL_DISCONNECTED,
|
||||
ESL_GENERR
|
||||
} esl_status_t;
|
||||
|
||||
#define BUF_CHUNK 65536 * 50
|
||||
@@ -309,6 +311,10 @@ typedef struct {
|
||||
int destroyed;
|
||||
} esl_handle_t;
|
||||
|
||||
#define esl_test_flag(obj, flag) ((obj)->flags & flag)
|
||||
#define esl_set_flag(obj, flag) (obj)->flags |= (flag)
|
||||
#define esl_clear_flag(obj, flag) (obj)->flags &= ~(flag)
|
||||
|
||||
/*! \brief Used internally for truth test */
|
||||
typedef enum {
|
||||
ESL_TRUE = 1,
|
||||
@@ -453,6 +459,8 @@ ESL_DECLARE(esl_status_t) esl_events(esl_handle_t *handle, esl_event_type_t etyp
|
||||
|
||||
ESL_DECLARE(int) esl_wait_sock(esl_socket_t sock, uint32_t ms, esl_poll_t flags);
|
||||
|
||||
ESL_DECLARE(unsigned int) esl_separate_string_string(char *buf, const char *delim, char **array, unsigned int arraylen);
|
||||
|
||||
#define esl_recv(_h) esl_recv_event(_h, 0, NULL)
|
||||
#define esl_recv_timed(_h, _ms) esl_recv_event_timed(_h, _ms, 0, NULL)
|
||||
|
||||
|
||||
@@ -42,7 +42,9 @@ extern "C" {
|
||||
|
||||
typedef enum {
|
||||
ESL_STACK_BOTTOM,
|
||||
ESL_STACK_TOP
|
||||
ESL_STACK_TOP,
|
||||
ESL_STACK_PUSH,
|
||||
ESL_STACK_UNSHIFT
|
||||
} esl_stack_t;
|
||||
|
||||
typedef enum {
|
||||
@@ -141,6 +143,10 @@ typedef enum {
|
||||
char *name;
|
||||
/*! the header value */
|
||||
char *value;
|
||||
/*! array space */
|
||||
char **array;
|
||||
/*! array index */
|
||||
int idx;
|
||||
/*! hash of the header name */
|
||||
unsigned long hash;
|
||||
struct esl_event_header *next;
|
||||
@@ -174,7 +180,7 @@ struct esl_event {
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
ESL_UNIQ_HEADERS = (1 << 0)
|
||||
ESL_EF_UNIQ_HEADERS = (1 << 0)
|
||||
} esl_event_flag_t;
|
||||
|
||||
|
||||
@@ -203,7 +209,11 @@ ESL_DECLARE(esl_status_t) esl_event_set_priority(esl_event_t *event, esl_priorit
|
||||
\param header_name the name of the header to read
|
||||
\return the value of the requested header
|
||||
*/
|
||||
ESL_DECLARE(char *)esl_event_get_header(esl_event_t *event, const char *header_name);
|
||||
|
||||
|
||||
ESL_DECLARE(esl_event_header_t *) esl_event_get_header_ptr(esl_event_t *event, const char *header_name);
|
||||
ESL_DECLARE(char *) esl_event_get_header_idx(esl_event_t *event, const char *header_name, int idx);
|
||||
#define esl_event_get_header(_e, _h) esl_event_get_header_idx(_e, _h, -1)
|
||||
|
||||
/*!
|
||||
\brief Retrieve the body value from an event
|
||||
@@ -223,6 +233,8 @@ ESL_DECLARE(char *)esl_event_get_body(esl_event_t *event);
|
||||
ESL_DECLARE(esl_status_t) esl_event_add_header(esl_event_t *event, esl_stack_t stack,
|
||||
const char *header_name, const char *fmt, ...); //PRINTF_FUNCTION(4, 5);
|
||||
|
||||
ESL_DECLARE(int) esl_event_add_array(esl_event_t *event, const char *var, const char *val);
|
||||
|
||||
/*!
|
||||
\brief Add a string header to an event
|
||||
\param event the event to add the header to
|
||||
@@ -250,6 +262,7 @@ ESL_DECLARE(void) esl_event_destroy(esl_event_t **event);
|
||||
\return ESL_SUCCESS if the event was duplicated
|
||||
*/
|
||||
ESL_DECLARE(esl_status_t) esl_event_dup(esl_event_t **event, esl_event_t *todup);
|
||||
ESL_DECLARE(void) esl_event_merge(esl_event_t *event, esl_event_t *tomerge);
|
||||
|
||||
/*!
|
||||
\brief Render the name of an event id enumeration
|
||||
|
||||
@@ -56,11 +56,13 @@ class ESLevent {
|
||||
virtual ~ESLevent();
|
||||
const char *serialize(const char *format = NULL);
|
||||
bool setPriority(esl_priority_t priority = ESL_PRIORITY_NORMAL);
|
||||
const char *getHeader(const char *header_name);
|
||||
const char *getHeader(const char *header_name, int idx = -1);
|
||||
char *getBody(void);
|
||||
const char *getType(void);
|
||||
bool addBody(const char *value);
|
||||
bool addHeader(const char *header_name, const char *value);
|
||||
bool pushHeader(const char *header_name, const char *value);
|
||||
bool unshiftHeader(const char *header_name, const char *value);
|
||||
bool delHeader(const char *header_name);
|
||||
const char *firstHeader(void);
|
||||
const char *nextHeader(void);
|
||||
|
||||
Reference in new issue
Block a user