ellecio2/elcaribe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MILESTONE 3: PJSIP Wrapper JNI completo y funcionando

Browse Source
This commit is contained in:
ellecio2
2025-11-03 10:58:02 -04:00
parent 31ffabe6cc
commit 9e5d0d8ebf
17865 changed files with 118001 additions and 1963586 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
GSMGateway/.gitignore vendored Normal file
View File

@@ -0,0 +1,15 @@
*.iml
.gradle
/local.properties
/.idea/caches
/.idea/libraries
/.idea/modules.xml
/.idea/workspace.xml
/.idea/navEditor.xml
/.idea/assetWizardSettings.xml
.DS_Store
/build
/captures
.externalNativeBuild
.cxx
local.properties

3
GSMGateway/.idea/.gitignore generated vendored Normal file
View File

@@ -0,0 +1,3 @@
# Default ignored files
/shelf/
/workspace.xml

6
GSMGateway/.idea/compiler.xml generated Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
<bytecodeTargetLevel target="21" />
</component>
</project>

10
GSMGateway/.idea/deploymentTargetSelector.xml generated Normal file
View File

@@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="deploymentTargetSelector">
<selectionStates>
<SelectionState runConfigName="app">
<option name="selectionMode" value="DROPDOWN" />
</SelectionState>
</selectionStates>
</component>
</project>

19
GSMGateway/.idea/gradle.xml generated Normal file
View File

@@ -0,0 +1,19 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="GradleSettings">
<option name="linkedExternalProjectsSettings">
<GradleProjectSettings>
<option name="testRunner" value="CHOOSE_PER_TEST" />
<option name="externalProjectPath" value="$PROJECT_DIR$" />
<option name="gradleJvm" value="#GRADLE_LOCAL_JAVA_HOME" />
<option name="modules">
<set>
<option value="$PROJECT_DIR$" />
<option value="$PROJECT_DIR$/app" />
</set>
</option>
<option name="resolveExternalAnnotations" value="false" />
</GradleProjectSettings>
</option>
</component>
</project>

6
GSMGateway/.idea/kotlinc.xml generated Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="KotlinJpsPluginSettings">
<option name="version" value="1.9.24" />
</component>
</project>

10
GSMGateway/.idea/migrations.xml generated Normal file
View File

@@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectMigrations">
<option name="MigrateToGradleLocalJavaHome">
<set>
<option value="$PROJECT_DIR$" />
</set>
</option>
</component>
</project>

10
GSMGateway/.idea/misc.xml generated Normal file
View File

@@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ExternalStorageConfigurationManager" enabled="true" />
<component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="jbr-21" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/build/classes" />
</component>
<component name="ProjectType">
<option name="id" value="Android" />
</component>
</project>

17
GSMGateway/.idea/runConfigurations.xml generated Normal file
View File

@@ -0,0 +1,17 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="RunConfigurationProducerService">
<option name="ignoredProducers">
<set>
<option value="com.intellij.execution.junit.AbstractAllInDirectoryConfigurationProducer" />
<option value="com.intellij.execution.junit.AllInPackageConfigurationProducer" />
<option value="com.intellij.execution.junit.PatternConfigurationProducer" />
<option value="com.intellij.execution.junit.TestInClassConfigurationProducer" />
<option value="com.intellij.execution.junit.UniqueIdConfigurationProducer" />
<option value="com.intellij.execution.junit.testDiscovery.JUnitTestDiscoveryConfigurationProducer" />
<option value="org.jetbrains.kotlin.idea.junit.KotlinJUnitRunConfigurationProducer" />
<option value="org.jetbrains.kotlin.idea.junit.KotlinPatternConfigurationProducer" />
</set>
</option>
</component>
</project>

6
GSMGateway/.idea/vcs.xml generated Normal file
View File

@@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$/.." vcs="Git" />
</component>
</project>

1
GSMGateway/app/.gitignore vendored Normal file
View File

@@ -0,0 +1 @@
/build

67
GSMGateway/app/build.gradle.kts Normal file
View File

@@ -0,0 +1,67 @@
plugins {
alias(libs.plugins.android.application)
alias(libs.plugins.kotlin.android)
}
android {
namespace = "com.gqlabs.gsmgateway"
compileSdk = 35
defaultConfig {
applicationId = "com.gqlabs.gsmgateway"
minSdk = 26
targetSdk = 35
versionCode = 1
versionName = "1.0"
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
ndk {
abiFilters.add("arm64-v8a")
}
externalNativeBuild {
cmake {
cppFlags("-std=c++17")
arguments("-DANDROID_STL=c++_shared")
}
}
}
buildTypes {
release {
isMinifyEnabled = false
proguardFiles(
getDefaultProguardFile("proguard-android-optimize.txt"),
"proguard-rules.pro"
)
}
}
compileOptions {
sourceCompatibility = JavaVersion.VERSION_11
targetCompatibility = JavaVersion.VERSION_11
}
kotlinOptions {
jvmTarget = "11"
}
externalNativeBuild {
cmake {
path("src/main/cpp/CMakeLists.txt")
version = "3.22.1"
}
}
buildFeatures {
viewBinding = true
}
}
dependencies {
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.appcompat)
implementation(libs.material)
implementation(libs.androidx.constraintlayout)
testImplementation(libs.junit)
androidTestImplementation(libs.androidx.junit)
androidTestImplementation(libs.androidx.espresso.core)
}

21
GSMGateway/app/proguard-rules.pro vendored Normal file
View File

@@ -0,0 +1,21 @@
# Add project specific ProGuard rules here.
# You can control the set of applied configuration files using the
# proguardFiles setting in build.gradle.
#
# For more details, see
# http://developer.android.com/guide/developing/tools/proguard.html
# If your project uses WebView with JS, uncomment the following
# and specify the fully qualified class name to the JavaScript interface
# class:
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
# public *;
#}
# Uncomment this to preserve the line number information for
# debugging stack traces.
#-keepattributes SourceFile,LineNumberTable
# If you keep the line number information, uncomment this to
# hide the original source file name.
#-renamesourcefileattribute SourceFile

24
GSMGateway/app/src/androidTest/java/com/gqlabs/gsmgateway/ExampleInstrumentedTest.kt Normal file
View File

@@ -0,0 +1,24 @@
package com.gqlabs.gsmgateway
import androidx.test.platform.app.InstrumentationRegistry
import androidx.test.ext.junit.runners.AndroidJUnit4
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.Assert.*
/**
* Instrumented test, which will execute on an Android device.
*
* See [testing documentation](http://d.android.com/tools/testing).
*/
@RunWith(AndroidJUnit4::class)
class ExampleInstrumentedTest {
@Test
fun useAppContext() {
// Context of the app under test.
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
assertEquals("com.gqlabs.gsmgateway", appContext.packageName)
}
}

38
GSMGateway/app/src/main/AndroidManifest.xml Normal file
View File

@@ -0,0 +1,38 @@
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools">
<!-- Permisos necesarios para PJSIP -->
<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.RECORD_AUDIO"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
<!-- Permisos para llamadas telefónicas (para futuro) -->
<uses-permission android:name="android.permission.CALL_PHONE"/>
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
<uses-permission android:name="android.permission.ANSWER_PHONE_CALLS"/>
<uses-permission android:name="android.permission.MANAGE_OWN_CALLS"/>
<application
android:allowBackup="true"
android:dataExtractionRules="@xml/data_extraction_rules"
android:fullBackupContent="@xml/backup_rules"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/Theme.GSMGateway"
tools:targetApi="31">
<activity
android:name=".MainActivity"
android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

99
GSMGateway/app/src/main/cpp/CMakeLists.txt Normal file
View File

@@ -0,0 +1,99 @@
cmake_minimum_required(VERSION 3.22.1)
project("gsmgateway")
add_definitions(
-DPJ_AUTOCONF=1
-DPJ_IS_LITTLE_ENDIAN=1
-DPJ_IS_BIG_ENDIAN=0
)
# Configurar C++17
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Incluir headers de PJSIP
include_directories(
${CMAKE_SOURCE_DIR}
)
# Biblioteca nativa principal
add_library(gsmgateway SHARED
native-lib.cpp
pjsip_wrapper.c
)
# Variables para simplificar rutas
set(PJSIP_LIBS_DIR ${CMAKE_SOURCE_DIR}/../jniLibs/${ANDROID_ABI})
# Importar todas las bibliotecas PJSIP como estáticas
add_library(pj STATIC IMPORTED)
set_target_properties(pj PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpj-aarch64-unknown-linux-android.a)
add_library(pjlib-util STATIC IMPORTED)
set_target_properties(pjlib-util PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjlib-util-aarch64-unknown-linux-android.a)
add_library(pjnath STATIC IMPORTED)
set_target_properties(pjnath PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjnath-aarch64-unknown-linux-android.a)
add_library(pjmedia STATIC IMPORTED)
set_target_properties(pjmedia PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjmedia-aarch64-unknown-linux-android.a)
add_library(pjmedia-audiodev STATIC IMPORTED)
set_target_properties(pjmedia-audiodev PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjmedia-audiodev-aarch64-unknown-linux-android.a)
add_library(pjmedia-codec STATIC IMPORTED)
set_target_properties(pjmedia-codec PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjmedia-codec-aarch64-unknown-linux-android.a)
add_library(pjmedia-videodev STATIC IMPORTED)
set_target_properties(pjmedia-videodev PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjmedia-videodev-aarch64-unknown-linux-android.a)
add_library(pjsdp STATIC IMPORTED)
set_target_properties(pjsdp PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjsdp-aarch64-unknown-linux-android.a)
add_library(pjsip STATIC IMPORTED)
set_target_properties(pjsip PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjsip-aarch64-unknown-linux-android.a)
add_library(pjsip-simple STATIC IMPORTED)
set_target_properties(pjsip-simple PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjsip-simple-aarch64-unknown-linux-android.a)
add_library(pjsip-ua STATIC IMPORTED)
set_target_properties(pjsip-ua PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjsip-ua-aarch64-unknown-linux-android.a)
add_library(pjsua STATIC IMPORTED)
set_target_properties(pjsua PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjsua-aarch64-unknown-linux-android.a)
add_library(pjsua2 STATIC IMPORTED)
set_target_properties(pjsua2 PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libpjsua2-aarch64-unknown-linux-android.a)
add_library(srtp STATIC IMPORTED)
set_target_properties(srtp PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libsrtp-aarch64-unknown-linux-android.a)
add_library(resample STATIC IMPORTED)
set_target_properties(resample PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libresample-aarch64-unknown-linux-android.a)
add_library(webrtc STATIC IMPORTED)
set_target_properties(webrtc PROPERTIES IMPORTED_LOCATION ${PJSIP_LIBS_DIR}/libwebrtc-aarch64-unknown-linux-android.a)
# Linkear todas las bibliotecas en orden correcto
target_link_libraries(gsmgateway
pjsua2
pjsua
pjsip-ua
pjsip-simple
pjsip
pjmedia-codec
pjmedia
pjmedia-audiodev
pjmedia-videodev
pjsdp
pjnath
pjlib-util
pj
srtp
resample
webrtc
mediandk
log
android
OpenSLES
)

189
GSMGateway/app/src/main/cpp/native-lib.cpp Normal file
View File

@@ -0,0 +1,189 @@
#include <jni.h>
#include <string>
#include <android/log.h>
#include "pjsip_wrapper.h"
#define LOG_TAG "GSMGateway-JNI"
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
// ============================================
// TEST INICIAL
// ============================================
extern "C" JNIEXPORT jstring JNICALL
Java_com_gqlabs_gsmgateway_MainActivity_stringFromJNI(
JNIEnv* env,
jobject /* this */) {
LOGI("🚀 GSM Gateway Native Library Loaded");
// Test básico de PJSIP
int status = gateway_init();
std::string result;
if (status == 0) {
LOGI("✅ Gateway initialized successfully");
result = "✅ PJSIP Gateway Ready!\n\n";
result += "Version: 2.14\n";
result += "Status: Initialized\n\n";
result += "Ready to register to PBX";
// Cleanup test
gateway_destroy();
} else {
LOGE("❌ Gateway initialization failed: %d", status);
result = "❌ Gateway initialization failed\n";
result += "Error: ";
result += gateway_get_last_error();
}
return env->NewStringUTF(result.c_str());
}
// ============================================
// FUNCIONES JNI - INICIALIZACIÓN
// ============================================
extern "C" JNIEXPORT jint JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeInit(
JNIEnv* env,
jobject thiz) {
LOGI("📱 nativeInit called");
return gateway_init();
}
extern "C" JNIEXPORT void JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeDestroy(
JNIEnv* env,
jobject thiz) {
LOGI("🔥 nativeDestroy called");
gateway_destroy();
}
// ============================================
// FUNCIONES JNI - REGISTRO
// ============================================
extern "C" JNIEXPORT jint JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeRegister(
JNIEnv* env,
jobject thiz,
jstring server,
jstring username,
jstring password) {
const char* srv = env->GetStringUTFChars(server, nullptr);
const char* user = env->GetStringUTFChars(username, nullptr);
const char* pass = env->GetStringUTFChars(password, nullptr);
LOGI("📞 nativeRegister: %s@%s", user, srv);
int result = gateway_register(srv, user, pass);
env->ReleaseStringUTFChars(server, srv);
env->ReleaseStringUTFChars(username, user);
env->ReleaseStringUTFChars(password, pass);
return result;
}
extern "C" JNIEXPORT jint JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeUnregister(
JNIEnv* env,
jobject thiz) {
LOGI("📴 nativeUnregister called");
return gateway_unregister();
}
extern "C" JNIEXPORT jboolean JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeIsRegistered(
JNIEnv* env,
jobject thiz) {
return gateway_is_registered() ? JNI_TRUE : JNI_FALSE;
}
// ============================================
// FUNCIONES JNI - LLAMADAS
// ============================================
extern "C" JNIEXPORT jint JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeMakeCall(
JNIEnv* env,
jobject thiz,
jstring dest_uri) {
const char* uri = env->GetStringUTFChars(dest_uri, nullptr);
LOGI("📲 nativeMakeCall: %s", uri);
int call_id = gateway_make_call(uri);
env->ReleaseStringUTFChars(dest_uri, uri);
return call_id;
}
extern "C" JNIEXPORT jint JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeAnswerCall(
JNIEnv* env,
jobject thiz,
jint call_id) {
LOGI("✅ nativeAnswerCall: %d", call_id);
return gateway_answer_call(call_id);
}
extern "C" JNIEXPORT jint JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeHangupCall(
JNIEnv* env,
jobject thiz,
jint call_id) {
LOGI("📴 nativeHangupCall: %d", call_id);
return gateway_hangup_call(call_id);
}
extern "C" JNIEXPORT jint JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeRejectCall(
JNIEnv* env,
jobject thiz,
jint call_id) {
LOGI("🚫 nativeRejectCall: %d", call_id);
return gateway_reject_call(call_id);
}
extern "C" JNIEXPORT jstring JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeGetCallInfo(
JNIEnv* env,
jobject thiz,
jint call_id) {
char info[256];
int status = gateway_get_call_info(call_id, info, sizeof(info));
if (status == 0) {
return env->NewStringUTF(info);
} else {
return env->NewStringUTF("Call info not available");
}
}
// ============================================
// FUNCIONES JNI - UTILIDADES
// ============================================
extern "C" JNIEXPORT jstring JNICALL
Java_com_gqlabs_gsmgateway_PJSIPManager_nativeGetLastError(
JNIEnv* env,
jobject thiz) {
return env->NewStringUTF(gateway_get_last_error());
}

187
GSMGateway/app/src/main/cpp/pj++/file.hpp Normal file
View File

@@ -0,0 +1,187 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_FILE_HPP__
#define __PJPP_FILE_HPP__
#include <pj/file_io.h>
#include <pj/file_access.h>
#include <pj++/types.hpp>
#include <pj++/pool.hpp>
//
// File API.
//
class Pj_File_API
{
public:
//
// Check file existance.
//
static bool file_exists(const char *filename)
{
return pj_file_exists(filename) != 0;
}
//
// Get file size.
//
static pj_off_t file_size(const char *filename)
{
return pj_file_size(filename);
}
//
// Delete file.
//
static pj_status_t file_delete(const char *filename)
{
return pj_file_delete(filename);
}
//
// Move/rename file.
//
static pj_status_t file_move(const char *oldname, const char *newname)
{
return pj_file_move(oldname, newname);
}
//
// Get stat.
//
static pj_status_t file_stat(const char *filename, pj_file_stat *buf)
{
return pj_file_getstat(filename, buf);
}
};
//
// File.
//
class Pj_File : public Pj_Object
{
public:
//
// Offset type to be used in setpos.
//
enum Offset_Type
{
PJ_SEEK_SET = PJ_SEEK_SET,
PJ_SEEK_CUR = PJ_SEEK_CUR,
PJ_SEEK_END = PJ_SEEK_END,
};
//
// Default constructor.
//
Pj_File()
: hnd_(0)
{
}
//
// Construct and open a file.
//
Pj_File(Pj_Pool *pool, const char *filename,
unsigned access = PJ_O_RDONLY)
: hnd_(NULL)
{
open(pool, filename, access);
}
//
// Destructor closes the file.
//
~Pj_File()
{
close();
}
//
// Open a file.
//
pj_status_t open(Pj_Pool *pool, const char *filename,
unsigned access = PJ_O_RDONLY )
{
close();
return pj_file_open(pool->pool_(), filename, access, &hnd_);
}
//
// Close a file.
//
void close()
{
if (hnd_ != 0) {
pj_file_close(hnd_);
hnd_ = 0;
}
}
//
// Write data.
//
pj_ssize_t write(const void *buff, pj_size_t size)
{
pj_ssize_t bytes = size;
if (pj_file_write(hnd_, buff, &bytes) != PJ_SUCCESS)
return -1;
return bytes;
}
//
// Read data.
//
pj_ssize_t read(void *buf, pj_size_t size)
{
pj_ssize_t bytes = size;
if (pj_file_read(hnd_, buf, &bytes) != PJ_SUCCESS)
return -1;
return bytes;
}
//
// Set file position.
//
pj_status_t setpos(pj_off_t offset, Offset_Type whence)
{
return pj_file_setpos(hnd_, offset,
(enum pj_file_seek_type)whence);
}
//
// Get file position.
//
pj_off_t getpos()
{
pj_off_t pos;
if (pj_file_getpos(hnd_, &pos) != PJ_SUCCESS)
return -1;
return pos;
}
private:
pj_oshandle_t hnd_;
};
#endif /* __PJPP_FILE_HPP__ */

155
GSMGateway/app/src/main/cpp/pj++/hash.hpp Normal file
View File

@@ -0,0 +1,155 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_HASH_HPP__
#define __PJPP_HASH_HPP__
#include <pj++/types.hpp>
#include <pj++/pool.hpp>
#include <pj/hash.h>
//
// Hash table.
//
class Pj_Hash_Table : public Pj_Object
{
public:
//
// Hash table iterator.
//
class iterator
{
public:
iterator()
{
}
explicit iterator(pj_hash_table_t *h, pj_hash_iterator_t *i)
: ht_(h), it_(i)
{
}
iterator(const iterator &rhs)
: ht_(rhs.ht_), it_(rhs.it_)
{
}
void operator++()
{
it_ = pj_hash_next(ht_, it_);
}
bool operator==(const iterator &rhs)
{
return ht_ == rhs.ht_ && it_ == rhs.it_;
}
iterator & operator=(const iterator &rhs)
{
ht_=rhs.ht_; it_=rhs.it_;
return *this;
}
private:
pj_hash_table_t *ht_;
pj_hash_iterator_t it_val_;
pj_hash_iterator_t *it_;
friend class Pj_Hash_Table;
};
//
// Construct hash table.
//
Pj_Hash_Table(Pj_Pool *pool, unsigned size)
{
table_ = pj_hash_create(pool->pool_(), size);
}
//
// Destroy hash table.
//
~Pj_Hash_Table()
{
}
//
// Calculate hash value.
//
static pj_uint32_t calc( pj_uint32_t initial_hval,
const void *key,
unsigned keylen = PJ_HASH_KEY_STRING)
{
return pj_hash_calc(initial_hval, key, keylen);
}
//
// Return pjlib compatible hash table object.
//
pj_hash_table_t *pj_hash_table_t_()
{
return table_;
}
//
// Get the value associated with the specified key.
//
void *get(const void *key, unsigned keylen = PJ_HASH_KEY_STRING)
{
return pj_hash_get(table_, key, keylen);
}
//
// Associate a value with a key.
// Set the value to NULL to delete the key from the hash table.
//
void set(Pj_Pool *pool,
const void *key,
void *value,
unsigned keylen = PJ_HASH_KEY_STRING)
{
pj_hash_set(pool->pool_(), table_, key, keylen, value);
}
//
// Get number of items in the hash table.
//
unsigned count()
{
return pj_hash_count(table_);
}
//
// Iterate hash table.
//
iterator begin()
{
iterator it(table_, NULL);
it.it_ = pj_hash_first(table_, &it.it_val_);
return it;
}
//
// End of items.
//
iterator end()
{
return iterator(table_, NULL);
}
private:
pj_hash_table_t *table_;
};
#endif /* __PJPP_HASH_HPP__ */

351
GSMGateway/app/src/main/cpp/pj++/list.hpp Normal file
View File

@@ -0,0 +1,351 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_LIST_HPP__
#define __PJPP_LIST_HPP__
#include <pj/list.h>
#include <pj++/pool.hpp>
//
// Linked-list.
//
// Note:
// List_Node must have public member next and prev. Normally
// it will be declared like:
//
// struct my_node
// {
// PJ_DECL_LIST_MEMBER(struct my_node);
// ..
// };
//
//
template <class List_Node>
class Pj_List : public Pj_Object
{
public:
//
// List const_iterator.
//
class const_iterator
{
public:
const_iterator()
: node_(NULL)
{}
const_iterator(const List_Node *nd)
: node_((List_Node*)nd)
{}
const List_Node * operator *()
{
return node_;
}
const List_Node * operator -> ()
{
return node_;
}
const_iterator operator++()
{
return const_iterator((const List_Node *)node_->next);
}
bool operator==(const const_iterator &rhs)
{
return node_ == rhs.node_;
}
bool operator!=(const const_iterator &rhs)
{
return node_ != rhs.node_;
}
protected:
List_Node *node_;
};
//
// List iterator.
//
class iterator : public const_iterator
{
public:
iterator()
{}
iterator(List_Node *nd)
: const_iterator(nd)
{}
List_Node * operator *()
{
return node_;
}
List_Node * operator -> ()
{
return node_;
}
iterator operator++()
{
return iterator((List_Node*)node_->next);
}
bool operator==(const iterator &rhs)
{
return node_ == rhs.node_;
}
bool operator!=(const iterator &rhs)
{
return node_ != rhs.node_;
}
};
//
// Default constructor.
//
Pj_List()
{
pj_list_init(&root_);
if (0) compiletest();
}
//
// You can cast Pj_List to pj_list
//
operator pj_list&()
{
return (pj_list&)root_;
}
operator const pj_list&()
{
return (const pj_list&)root_;
}
//
// You can cast Pj_List to pj_list* too
//
operator pj_list*()
{
return (pj_list*)&root_;
}
operator const pj_list*()
{
return (const pj_list*)&root_;
}
//
// Check if list is empty.
//
bool empty() const
{
return pj_list_empty(&root_);
}
//
// Get first element.
//
iterator begin()
{
return iterator(root_.next);
}
//
// Get first element.
//
const_iterator begin() const
{
return const_iterator(root_.next);
}
//
// Get end-of-element
//
const_iterator end() const
{
return const_iterator((List_Node*)&root_);
}
//
// Get end-of-element
//
iterator end()
{
return iterator((List_Node*)&root_);
}
//
// Insert node.
//
void insert_before (iterator &pos, List_Node *node)
{
pj_list_insert_before( *pos, node );
}
//
// Insert node.
//
void insert_after(iterator &pos, List_Node *node)
{
pj_list_insert_after(*pos, node);
}
//
// Merge list.
//
void merge_first(List_Node *list2)
{
pj_list_merge_first(&root_, list2);
}
//
// Merge list.
//
void merge_last(Pj_List *list)
{
pj_list_merge_last(&root_, &list->root_);
}
//
// Insert list.
//
void insert_nodes_before(iterator &pos, Pj_List *list2)
{
pj_list_insert_nodes_before(*pos, &list2->root_);
}
//
// Insert list.
//
void insert_nodes_after(iterator &pos, Pj_List *list2)
{
pj_list_insert_nodes_after(*pos, &list2->root_);
}
//
// Erase an element.
//
void erase(iterator &it)
{
pj_list_erase(*it);
}
//
// Get first element.
//
List_Node *front()
{
return root_.next;
}
//
// Get first element.
//
const List_Node *front() const
{
return root_.next;
}
//
// Remove first element.
//
void pop_front()
{
pj_list_erase(root_.next);
}
//
// Get last element.
//
List_Node *back()
{
return root_.prev;
}
//
// Get last element.
//
const List_Node *back() const
{
return root_.prev;
}
//
// Remove last element.
//
void pop_back()
{
pj_list_erase(root_.prev);
}
//
// Find a node.
//
iterator find(List_Node *node)
{
List_Node *n = pj_list_find_node(&root_, node);
return n ? iterator(n) : end();
}
//
// Find a node.
//
const_iterator find(List_Node *node) const
{
List_Node *n = pj_list_find_node(&root_, node);
return n ? const_iterator(n) : end();
}
//
// Insert a node in the back.
//
void push_back(List_Node *node)
{
pj_list_insert_after(root_.prev, node);
}
//
// Insert a node in the front.
//
void push_front(List_Node *node)
{
pj_list_insert_before(root_.next, node);
}
//
// Remove all elements.
//
void clear()
{
root_.next = &root_;
root_.prev = &root_;
}
private:
struct RootNode
{
PJ_DECL_LIST_MEMBER(List_Node);
} root_;
void compiletest()
{
// If you see error in this line,
// it's because List_Node is not derived from Pj_List_Node.
List_Node *n = (List_Node*)0;
n = (List_Node *)n->next; n = (List_Node *)n->prev;
}
};
#endif /* __PJPP_LIST_HPP__ */

148
GSMGateway/app/src/main/cpp/pj++/lock.hpp Normal file
View File

@@ -0,0 +1,148 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_LOCK_HPP__
#define __PJPP_LOCK_HPP__
#include <pj++/types.hpp>
#include <pj/lock.h>
#include <pj++/pool.hpp>
//////////////////////////////////////////////////////////////////////////////
// Lock object.
//
class Pj_Lock : public Pj_Object
{
public:
//
// Constructor.
//
explicit Pj_Lock(pj_lock_t *lock)
: lock_(lock)
{
}
//
// Destructor.
//
~Pj_Lock()
{
if (lock_)
pj_lock_destroy(lock_);
}
//
// Get pjlib compatible lock object.
//
pj_lock_t *pj_lock_t_()
{
return lock_;
}
//
// acquire lock.
//
pj_status_t acquire()
{
return pj_lock_acquire(lock_);
}
//
// release lock,.
//
pj_status_t release()
{
return pj_lock_release(lock_);
}
protected:
pj_lock_t *lock_;
};
//////////////////////////////////////////////////////////////////////////////
// Null lock object.
//
class Pj_Null_Lock : public Pj_Lock
{
public:
//
// Default constructor.
//
explicit Pj_Null_Lock(Pj_Pool *pool, const char *name = NULL)
: Pj_Lock(NULL)
{
pj_lock_create_null_mutex(pool->pool_(), name, &lock_);
}
};
//////////////////////////////////////////////////////////////////////////////
// Simple mutex lock object.
//
class Pj_Simple_Mutex_Lock : public Pj_Lock
{
public:
//
// Default constructor.
//
explicit Pj_Simple_Mutex_Lock(Pj_Pool *pool, const char *name = NULL)
: Pj_Lock(NULL)
{
pj_lock_create_simple_mutex(pool->pool_(), name, &lock_);
}
};
//////////////////////////////////////////////////////////////////////////////
// Recursive mutex lock object.
//
class Pj_Recursive_Mutex_Lock : public Pj_Lock
{
public:
//
// Default constructor.
//
explicit Pj_Recursive_Mutex_Lock(Pj_Pool *pool, const char *name = NULL)
: Pj_Lock(NULL)
{
pj_lock_create_recursive_mutex(pool->pool_(), name, &lock_);
}
};
//////////////////////////////////////////////////////////////////////////////
// Semaphore lock object.
//
class Pj_Semaphore_Lock : public Pj_Lock
{
public:
//
// Default constructor.
//
explicit Pj_Semaphore_Lock(Pj_Pool *pool,
unsigned max=PJ_MAXINT32,
unsigned initial=0,
const char *name=NULL)
: Pj_Lock(NULL)
{
pj_lock_create_semaphore(pool->pool_(), name, initial, max, &lock_);
}
};
#endif /* __PJPP_LOCK_HPP__ */

869
GSMGateway/app/src/main/cpp/pj++/os.hpp Normal file
View File

@@ -0,0 +1,869 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_OS_HPP__
#define __PJPP_OS_HPP__
#include <pj/os.h>
#include <pj/string.h>
#include <pj++/types.hpp>
#include <pj++/pool.hpp>
class Pj_Thread;
//
// Thread API.
//
class Pj_Thread_API
{
public:
//
// Create a thread.
//
static pj_status_t create( Pj_Pool *pool, pj_thread_t **thread,
pj_thread_proc *proc, void *arg,
unsigned flags = 0,
const char *name = NULL,
pj_size_t stack_size = 0 )
{
return pj_thread_create(pool->pool_(), name, proc, arg, stack_size,
flags, thread);
}
//
// Register a thread.
//
static pj_status_t register_this_thread( pj_thread_desc desc,
pj_thread_t **thread,
const char *name = NULL )
{
return pj_thread_register( name, desc, thread );
}
//
// Get current thread.
// Will return pj_thread_t (sorry folks, not Pj_Thread).
//
static pj_thread_t *this_thread()
{
return pj_thread_this();
}
//
// Get thread name.
//
static const char *get_name(pj_thread_t *thread)
{
return pj_thread_get_name(thread);
}
//
// Resume thread.
//
static pj_status_t resume(pj_thread_t *thread)
{
return pj_thread_resume(thread);
}
//
// Sleep.
//
static pj_status_t sleep(unsigned msec)
{
return pj_thread_sleep(msec);
}
//
// Join the specified thread.
//
static pj_status_t join(pj_thread_t *thread)
{
return pj_thread_join(thread);
}
//
// Destroy thread
//
static pj_status_t destroy(pj_thread_t *thread)
{
return pj_thread_destroy(thread);
}
};
//
// Thread object.
//
// How to use:
// Derive a class from this class, then override main().
//
class Pj_Thread : public Pj_Object
{
public:
enum Flags
{
FLAG_SUSPENDED = PJ_THREAD_SUSPENDED
};
//
// Default constructor.
//
Pj_Thread()
: thread_(NULL)
{
}
//
// Destroy thread.
//
~Pj_Thread()
{
destroy();
}
//
// This is the main thread function.
//
virtual int main() = 0;
//
// Start a thread.
//
pj_status_t create( Pj_Pool *pool,
unsigned flags = 0,
const char *thread_name = NULL,
pj_size_t stack_size = PJ_THREAD_DEFAULT_STACK_SIZE)
{
destroy();
return Pj_Thread_API::create( pool, &thread_, &thread_proc, this,
flags, thread_name, stack_size);
}
//
// Get pjlib compatible thread object.
//
pj_thread_t *pj_thread_t_()
{
return thread_;
}
//
// Get thread name.
//
const char *get_name()
{
return Pj_Thread_API::get_name(thread_);
}
//
// Resume a suspended thread.
//
pj_status_t resume()
{
return Pj_Thread_API::resume(thread_);
}
//
// Join this thread.
//
pj_status_t join()
{
return Pj_Thread_API::join(thread_);
}
//
// Destroy thread.
//
pj_status_t destroy()
{
if (thread_) {
Pj_Thread_API::destroy(thread_);
thread_ = NULL;
}
}
protected:
pj_thread_t *thread_;
static int PJ_THREAD_FUNC thread_proc(void *obj)
{
Pj_Thread *thread_class = (Pj_Thread*)obj;
return thread_class->main();
}
};
//
// External Thread
// (threads that were started by external means, i.e. not
// with Pj_Thread::create).
//
// This class will normally be defined as local variable in
// external thread's stack, normally inside thread's main proc.
// But be aware that the handle will be destroyed on destructor!
//
class Pj_External_Thread : public Pj_Thread
{
public:
Pj_External_Thread()
{
}
//
// Register external thread so that pjlib functions can work
// in that thread.
//
pj_status_t register_this_thread( const char *name=NULL )
{
return Pj_Thread_API::register_this_thread(desc_, &thread_,name);
}
private:
pj_thread_desc desc_;
};
//
// Thread specific data/thread local storage/TLS.
//
class Pj_Thread_Local_API
{
public:
//
// Allocate thread local storage (TLS) index.
//
static pj_status_t alloc(long *index)
{
return pj_thread_local_alloc(index);
}
//
// Free TLS index.
//
static void free(long index)
{
pj_thread_local_free(index);
}
//
// Set thread specific data.
//
static pj_status_t set(long index, void *value)
{
return pj_thread_local_set(index, value);
}
//
// Get thread specific data.
//
static void *get(long index)
{
return pj_thread_local_get(index);
}
};
//
// Atomic variable
//
// How to use:
// Pj_Atomic_Var var(pool, 0);
// var.set(..);
//
class Pj_Atomic_Var : public Pj_Object
{
public:
//
// Default constructor, initialize variable with NULL.
//
Pj_Atomic_Var()
: var_(NULL)
{
}
//
// Construct atomic variable.
//
Pj_Atomic_Var(Pj_Pool *pool, pj_atomic_value_t value)
: var_(NULL)
{
create(pool, value);
}
//
// Destructor.
//
~Pj_Atomic_Var()
{
destroy();
}
//
// Create atomic variable.
//
pj_status_t create( Pj_Pool *pool, pj_atomic_value_t value)
{
destroy();
return pj_atomic_create(pool->pool_(), value, &var_);
}
//
// Destroy.
//
void destroy()
{
if (var_) {
pj_atomic_destroy(var_);
var_ = NULL;
}
}
//
// Get pjlib compatible atomic variable.
//
pj_atomic_t *pj_atomic_t_()
{
return var_;
}
//
// Set the value.
//
void set(pj_atomic_value_t val)
{
pj_atomic_set(var_, val);
}
//
// Get the value.
//
pj_atomic_value_t get()
{
return pj_atomic_get(var_);
}
//
// Increment.
//
void inc()
{
pj_atomic_inc(var_);
}
//
// Increment and get the result.
//
pj_atomic_value_t inc_and_get()
{
return pj_atomic_inc_and_get(var_);
}
//
// Decrement.
//
void dec()
{
pj_atomic_dec(var_);
}
//
// Decrement and get the result.
//
pj_atomic_value_t dec_and_get()
{
return pj_atomic_dec_and_get(var_);
}
//
// Add the variable.
//
void add(pj_atomic_value_t value)
{
pj_atomic_add(var_, value);
}
//
// Add the variable and get the value.
//
pj_atomic_value_t add_and_get(pj_atomic_value_t value)
{
return pj_atomic_add_and_get(var_, value );
}
private:
pj_atomic_t *var_;
};
//
// Mutex
//
class Pj_Mutex : public Pj_Object
{
public:
//
// Mutex type.
//
enum Type
{
DEFAULT = PJ_MUTEX_DEFAULT,
SIMPLE = PJ_MUTEX_SIMPLE,
RECURSE = PJ_MUTEX_RECURSE,
};
//
// Default constructor will create default mutex.
//
explicit Pj_Mutex(Pj_Pool *pool, Type type = DEFAULT,
const char *name = NULL)
: mutex_(NULL)
{
create(pool, type, name);
}
//
// Destructor.
//
~Pj_Mutex()
{
destroy();
}
//
// Create mutex.
//
pj_status_t create( Pj_Pool *pool, Type type, const char *name = NULL)
{
destroy();
return pj_mutex_create( pool->pool_(), name, type,
&mutex_ );
}
//
// Create simple mutex.
//
pj_status_t create_simple( Pj_Pool *pool,const char *name = NULL)
{
return create(pool, SIMPLE, name);
}
//
// Create recursive mutex.
//
pj_status_t create_recursive( Pj_Pool *pool, const char *name = NULL )
{
return create(pool, RECURSE, name);
}
//
// Get pjlib compatible mutex object.
//
pj_mutex_t *pj_mutex_t_()
{
return mutex_;
}
//
// Destroy mutex.
//
void destroy()
{
if (mutex_) {
pj_mutex_destroy(mutex_);
mutex_ = NULL;
}
}
//
// Lock mutex.
//
pj_status_t acquire()
{
return pj_mutex_lock(mutex_);
}
//
// Unlock mutex.
//
pj_status_t release()
{
return pj_mutex_unlock(mutex_);
}
//
// Try locking the mutex.
//
pj_status_t tryacquire()
{
return pj_mutex_trylock(mutex_);
}
private:
pj_mutex_t *mutex_;
};
//
// Semaphore
//
class Pj_Semaphore : public Pj_Object
{
public:
//
// Construct semaphore
//
Pj_Semaphore(Pj_Pool *pool, unsigned max,
unsigned initial = 0, const char *name = NULL)
: sem_(NULL)
{
create(pool, max, initial, name);
}
//
// Destructor.
//
~Pj_Semaphore()
{
destroy();
}
//
// Create semaphore
//
pj_status_t create( Pj_Pool *pool, unsigned max,
unsigned initial = 0, const char *name = NULL )
{
destroy();
return pj_sem_create( pool->pool_(), name, initial, max, &sem_);
}
//
// Destroy semaphore.
//
void destroy()
{
if (sem_) {
pj_sem_destroy(sem_);
sem_ = NULL;
}
}
//
// Get pjlib compatible semaphore object.
//
pj_sem_t *pj_sem_t_()
{
return (pj_sem_t*)this;
}
//
// Wait semaphore.
//
pj_status_t wait()
{
return pj_sem_wait(this->pj_sem_t_());
}
//
// Wait semaphore.
//
pj_status_t acquire()
{
return wait();
}
//
// Try wait semaphore.
//
pj_status_t trywait()
{
return pj_sem_trywait(this->pj_sem_t_());
}
//
// Try wait semaphore.
//
pj_status_t tryacquire()
{
return trywait();
}
//
// Post semaphore.
//
pj_status_t post()
{
return pj_sem_post(this->pj_sem_t_());
}
//
// Post semaphore.
//
pj_status_t release()
{
return post();
}
private:
pj_sem_t *sem_;
};
//
// Event object.
//
class Pj_Event
{
public:
//
// Construct event object.
//
Pj_Event( Pj_Pool *pool, bool manual_reset = false,
bool initial = false, const char *name = NULL )
: event_(NULL)
{
create(pool, manual_reset, initial, name);
}
//
// Destructor.
//
~Pj_Event()
{
destroy();
}
//
// Create event object.
//
pj_status_t create( Pj_Pool *pool, bool manual_reset = false,
bool initial = false, const char *name = NULL)
{
destroy();
return pj_event_create(pool->pool_(), name, manual_reset, initial,
&event_);
}
//
// Get pjlib compatible event object.
//
pj_event_t *pj_event_t_()
{
return event_;
}
//
// Destroy event object.
//
void destroy()
{
if (event_) {
pj_event_destroy(event_);
event_ = NULL;
}
}
//
// Wait.
//
pj_status_t wait()
{
return pj_event_wait(event_);
}
//
// Try wait.
//
pj_status_t trywait()
{
return pj_event_trywait(event_);
}
//
// Set event state to signalled.
//
pj_status_t set()
{
return pj_event_set(this->pj_event_t_());
}
//
// Release one waiting thread.
//
pj_status_t pulse()
{
return pj_event_pulse(this->pj_event_t_());
}
//
// Set a non-signalled.
//
pj_status_t reset()
{
return pj_event_reset(this->pj_event_t_());
}
private:
pj_event_t *event_;
};
//
// Timestamp
//
class Pj_Timestamp
{
public:
pj_status_t get_timestamp()
{
return pj_get_timestamp(&ts_);
}
Pj_Timestamp& operator += (const Pj_Timestamp &rhs)
{
pj_add_timestamp(&ts_, &rhs.ts_);
return *this;
}
Pj_Timestamp& operator -= (const Pj_Timestamp &rhs)
{
pj_sub_timestamp(&ts_, &rhs.ts_);
return *this;
}
Pj_Time_Val to_time() const
{
Pj_Timestamp zero;
pj_memset(&zero, 0, sizeof(zero));
return Pj_Time_Val(pj_elapsed_time(&zero.ts_, &ts_));
}
pj_uint32_t to_msec() const
{
Pj_Timestamp zero;
pj_memset(&zero, 0, sizeof(zero));
return pj_elapsed_msec(&zero.ts_, &ts_);
}
pj_uint32_t to_usec() const
{
Pj_Timestamp zero;
pj_memset(&zero, 0, sizeof(zero));
return pj_elapsed_usec(&zero.ts_, &ts_);
}
pj_uint32_t to_nanosec() const
{
Pj_Timestamp zero;
pj_memset(&zero, 0, sizeof(zero));
return pj_elapsed_nanosec(&zero.ts_, &ts_);
}
pj_uint32_t to_cycle() const
{
Pj_Timestamp zero;
pj_memset(&zero, 0, sizeof(zero));
return pj_elapsed_cycle(&zero.ts_, &ts_);
}
private:
pj_timestamp ts_;
};
//
// OS abstraction.
//
class Pj_OS_API
{
public:
//
// Get current time.
//
static pj_status_t gettimeofday( Pj_Time_Val *tv )
{
return pj_gettimeofday(tv);
}
//
// Parse to time of day.
//
static pj_status_t time_decode( const Pj_Time_Val *tv,
pj_parsed_time *pt )
{
return pj_time_decode(tv, pt);
}
//
// Parse from time of day.
//
static pj_status_t time_encode( const pj_parsed_time *pt,
Pj_Time_Val *tv)
{
return pj_time_encode(pt, tv);
}
//
// Convert to GMT.
//
static pj_status_t time_local_to_gmt( Pj_Time_Val *tv )
{
return pj_time_local_to_gmt( tv );
}
//
// Convert time to local.
//
static pj_status_t time_gmt_to_local( Pj_Time_Val *tv)
{
return pj_time_gmt_to_local( tv );
}
};
//
// Timeval inlines.
//
inline pj_status_t Pj_Time_Val::gettimeofday()
{
return Pj_OS_API::gettimeofday(this);
}
inline pj_parsed_time Pj_Time_Val::decode()
{
pj_parsed_time pt;
Pj_OS_API::time_decode(this, &pt);
return pt;
}
inline pj_status_t Pj_Time_Val::encode(const pj_parsed_time *pt)
{
return Pj_OS_API::time_encode(pt, this);
}
inline pj_status_t Pj_Time_Val::to_gmt()
{
return Pj_OS_API::time_local_to_gmt(this);
}
inline pj_status_t Pj_Time_Val::to_local()
{
return Pj_OS_API::time_gmt_to_local(this);
}
#endif /* __PJPP_OS_HPP__ */

278
GSMGateway/app/src/main/cpp/pj++/pool.hpp Normal file
View File

@@ -0,0 +1,278 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_POOL_HPP__
#define __PJPP_POOL_HPP__
#include <pj/pool.h>
class Pj_Pool;
class Pj_Caching_Pool;
//
// Base class for all Pjlib objects
//
class Pj_Object
{
public:
void *operator new(unsigned int class_size, Pj_Pool *pool);
void *operator new(unsigned int class_size, Pj_Pool &pool);
void operator delete(void*)
{
}
void operator delete(void*, Pj_Pool*)
{
}
void operator delete(void*, Pj_Pool&)
{
}
//
// Inline implementations at the end of this file.
//
private:
// Can not use normal new operator; must use pool.
// e.g.:
// obj = new(pool) Pj_The_Object(pool, ...);
//
void *operator new(unsigned int)
{}
};
//
// Pool.
//
class Pj_Pool : public Pj_Object
{
public:
//
// Default constructor, initializes internal pool to NULL.
// Application must call attach() some time later.
//
Pj_Pool()
: p_(NULL)
{
}
//
// Create pool.
//
Pj_Pool(Pj_Caching_Pool &caching_pool,
pj_size_t initial_size,
pj_size_t increment_size,
const char *name = NULL,
pj_pool_callback *callback = NULL);
//
// Construct from existing pool.
//
explicit Pj_Pool(pj_pool_t *pool)
: p_(pool)
{
}
//
// Attach existing pool.
//
void attach(pj_pool_t *pool)
{
p_ = pool;
}
//
// Destructor.
//
// Release pool back to factory. Remember: if you delete pool, then
// make sure that all objects that have been allocated from this pool
// have been properly destroyed.
//
// This is where C++ is trickier than plain C!!
//
~Pj_Pool()
{
if (p_)
pj_pool_release(p_);
}
//
// Get name.
//
const char *getobjname() const
{
return pj_pool_getobjname(p_);
}
//
// You can cast Pj_Pool to pj_pool_t*
//
operator pj_pool_t*()
{
return p_;
}
//
// Get pjlib compatible pool object.
//
pj_pool_t *pool_()
{
return p_;
}
//
// Get pjlib compatible pool object.
//
const pj_pool_t *pool_() const
{
return p_;
}
//
// Get pjlib compatible pool object.
//
pj_pool_t *pj_pool_t_()
{
return p_;
}
//
// Reset pool.
//
void reset()
{
pj_pool_reset(p_);
}
//
// Get current capacity.
//
pj_size_t get_capacity()
{
pj_pool_get_capacity(p_);
}
//
// Get current total bytes allocated from the pool.
//
pj_size_t get_used_size()
{
pj_pool_get_used_size(p_);
}
//
// Allocate.
//
void *alloc(pj_size_t size)
{
return pj_pool_alloc(p_, size);
}
//
// Allocate elements and zero fill the memory.
//
void *calloc(pj_size_t count, pj_size_t elem)
{
return pj_pool_calloc(p_, count, elem);
}
//
// Allocate and zero fill memory.
//
void *zalloc(pj_size_t size)
{
return pj_pool_zalloc(p_, size);
}
private:
pj_pool_t *p_;
};
//
// Caching pool.
//
class Pj_Caching_Pool
{
public:
//
// Construct caching pool.
//
Pj_Caching_Pool( pj_size_t cache_capacity = 0,
const pj_pool_factory_policy *pol=&pj_pool_factory_default_policy)
{
pj_caching_pool_init(&cp_, pol, cache_capacity);
}
//
// Destroy caching pool.
//
~Pj_Caching_Pool()
{
pj_caching_pool_destroy(&cp_);
}
//
// Create pool.
//
pj_pool_t *create_pool( pj_size_t initial_size,
pj_size_t increment_size,
const char *name = NULL,
pj_pool_callback *callback = NULL)
{
return (pj_pool_t*)(*cp_.factory.create_pool)(&cp_.factory, name,
initial_size,
increment_size,
callback);
}
private:
pj_caching_pool cp_;
};
//
// Inlines for Pj_Object
//
inline void *Pj_Object::operator new(unsigned int class_size, Pj_Pool *pool)
{
return pool->alloc(class_size);
}
inline void *Pj_Object::operator new(unsigned int class_size, Pj_Pool &pool)
{
return pool.alloc(class_size);
}
//
// Inlines for Pj_Pool
//
inline Pj_Pool::Pj_Pool( Pj_Caching_Pool &caching_pool,
pj_size_t initial_size,
pj_size_t increment_size,
const char *name,
pj_pool_callback *callback)
{
p_ = caching_pool.create_pool(initial_size, increment_size, name,
callback);
}
#endif /* __PJPP_POOL_HPP__ */

514
GSMGateway/app/src/main/cpp/pj++/proactor.hpp Normal file
View File

@@ -0,0 +1,514 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_PROACTOR_HPP__
#define __PJPP_PROACTOR_HPP__
#include <pj/ioqueue.h>
#include <pj++/pool.hpp>
#include <pj++/sock.hpp>
#include <pj++/timer.hpp>
#include <pj/errno.h>
class Pj_Proactor;
class Pj_Event_Handler;
//////////////////////////////////////////////////////////////////////////////
// Asynchronous operation key.
//
// Applications may inheric this class to put their application
// specific data.
//
class Pj_Async_Op : public pj_ioqueue_op_key_t
{
public:
//
// Construct with null handler.
// App must call set_handler() before use.
//
Pj_Async_Op()
: handler_(NULL)
{
pj_ioqueue_op_key_init(this, sizeof(*this));
}
//
// Constructor.
//
explicit Pj_Async_Op(Pj_Event_Handler *handler)
: handler_(handler)
{
pj_ioqueue_op_key_init(this, sizeof(*this));
}
//
// Set handler.
//
void set_handler(Pj_Event_Handler *handler)
{
handler_ = handler;
}
//
// Check whether operation is still pending for this key.
//
bool is_pending();
//
// Cancel the operation.
//
bool cancel(pj_ssize_t bytes_status=-PJ_ECANCELLED);
protected:
Pj_Event_Handler *handler_;
};
//////////////////////////////////////////////////////////////////////////////
// Event handler.
//
// Applications should inherit this class to receive various event
// notifications.
//
// Applications should implement get_socket_handle().
//
class Pj_Event_Handler : public Pj_Object
{
friend class Pj_Proactor;
public:
//
// Default constructor.
//
Pj_Event_Handler()
: key_(NULL)
{
pj_memset(&timer_, 0, sizeof(timer_));
timer_.user_data = this;
timer_.cb = &timer_callback;
}
//
// Destroy.
//
virtual ~Pj_Event_Handler()
{
unregister();
}
//
// Unregister this handler from the ioqueue.
//
void unregister()
{
if (key_) {
pj_ioqueue_unregister(key_);
key_ = NULL;
}
}
//
// Get socket handle associated with this.
//
virtual pj_sock_t get_socket_handle()
{
return PJ_INVALID_SOCKET;
}
//
// Start async receive.
//
pj_status_t recv( Pj_Async_Op *op_key,
void *buf, pj_ssize_t *len,
unsigned flags)
{
return pj_ioqueue_recv( key_, op_key,
buf, len, flags);
}
//
// Start async recvfrom()
//
pj_status_t recvfrom( Pj_Async_Op *op_key,
void *buf, pj_ssize_t *len, unsigned flags,
Pj_Inet_Addr *addr)
{
addr->addrlen_ = sizeof(Pj_Inet_Addr);
return pj_ioqueue_recvfrom( key_, op_key, buf, len, flags,
addr, &addr->addrlen_ );
}
//
// Start async send()
//
pj_status_t send( Pj_Async_Op *op_key,
const void *data, pj_ssize_t *len,
unsigned flags)
{
return pj_ioqueue_send( key_, op_key, data, len, flags);
}
//
// Start async sendto()
//
pj_status_t sendto( Pj_Async_Op *op_key,
const void *data, pj_ssize_t *len, unsigned flags,
const Pj_Inet_Addr &addr)
{
return pj_ioqueue_sendto(key_, op_key, data, len, flags,
&addr, sizeof(addr));
}
#if PJ_HAS_TCP
//
// Start async connect()
//
pj_status_t connect(const Pj_Inet_Addr &addr)
{
return pj_ioqueue_connect(key_, &addr, sizeof(addr));
}
//
// Start async accept().
//
pj_status_t accept( Pj_Async_Op *op_key,
Pj_Socket *sock,
Pj_Inet_Addr *local = NULL,
Pj_Inet_Addr *remote = NULL)
{
int *addrlen = local ? &local->addrlen_ : NULL;
return pj_ioqueue_accept( key_, op_key, &sock->sock_,
local, remote, addrlen );
}
#endif
protected:
//////////////////
// Overridables
//////////////////
//
// Timeout callback.
//
virtual void on_timeout(int)
{
}
//
// On read complete callback.
//
virtual void on_read_complete( Pj_Async_Op*, pj_ssize_t)
{
}
//
// On write complete callback.
//
virtual void on_write_complete( Pj_Async_Op *, pj_ssize_t)
{
}
#if PJ_HAS_TCP
//
// On connect complete callback.
//
virtual void on_connect_complete(pj_status_t)
{
}
//
// On new connection callback.
//
virtual void on_accept_complete( Pj_Async_Op*, pj_sock_t, pj_status_t)
{
}
#endif
private:
pj_ioqueue_key_t *key_;
pj_timer_entry timer_;
friend class Pj_Proactor;
friend class Pj_Async_Op;
//
// Static timer callback.
//
static void timer_callback( pj_timer_heap_t*,
struct pj_timer_entry *entry)
{
Pj_Event_Handler *handler =
(Pj_Event_Handler*) entry->user_data;
handler->on_timeout(entry->id);
}
};
inline bool Pj_Async_Op::is_pending()
{
return pj_ioqueue_is_pending(handler_->key_, this) != 0;
}
inline bool Pj_Async_Op::cancel(pj_ssize_t bytes_status)
{
return pj_ioqueue_post_completion(handler_->key_, this,
bytes_status) == PJ_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////////
// Proactor
//
class Pj_Proactor : public Pj_Object
{
public:
//
// Default constructor, initializes to NULL.
//
Pj_Proactor()
: ioq_(NULL), th_(NULL)
{
cb_.on_read_complete = &read_complete_cb;
cb_.on_write_complete = &write_complete_cb;
cb_.on_accept_complete = &accept_complete_cb;
cb_.on_connect_complete = &connect_complete_cb;
}
//
// Construct proactor.
//
Pj_Proactor( Pj_Pool *pool, pj_size_t max_fd,
pj_size_t max_timer_entries )
: ioq_(NULL), th_(NULL)
{
cb_.on_read_complete = &read_complete_cb;
cb_.on_write_complete = &write_complete_cb;
cb_.on_accept_complete = &accept_complete_cb;
cb_.on_connect_complete = &connect_complete_cb;
create(pool, max_fd, max_timer_entries);
}
//
// Destructor.
//
~Pj_Proactor()
{
destroy();
}
//
// Create proactor.
//
pj_status_t create( Pj_Pool *pool, pj_size_t max_fd,
pj_size_t timer_entry_count)
{
pj_status_t status;
destroy();
status = pj_ioqueue_create(pool->pool_(), max_fd, &ioq_);
if (status != PJ_SUCCESS)
return status;
status = pj_timer_heap_create(pool->pool_(),
timer_entry_count, &th_);
if (status != PJ_SUCCESS) {
pj_ioqueue_destroy(ioq_);
ioq_ = NULL;
return NULL;
}
return status;
}
//
// Destroy proactor.
//
void destroy()
{
if (ioq_) {
pj_ioqueue_destroy(ioq_);
ioq_ = NULL;
}
if (th_) {
pj_timer_heap_destroy(th_);
th_ = NULL;
}
}
//
// Register handler.
// This will call handler->get_socket_handle()
//
pj_status_t register_socket_handler(Pj_Pool *pool,
Pj_Event_Handler *handler)
{
return pj_ioqueue_register_sock( pool->pool_(), ioq_,
handler->get_socket_handle(),
handler, &cb_, &handler->key_ );
}
//
// Unregister handler.
//
static void unregister_handler(Pj_Event_Handler *handler)
{
if (handler->key_) {
pj_ioqueue_unregister( handler->key_ );
handler->key_ = NULL;
}
}
//
// Scheduler timer.
//
bool schedule_timer( Pj_Event_Handler *handler,
const Pj_Time_Val &delay,
int id=-1)
{
return schedule_timer(th_, handler, delay, id);
}
//
// Cancel timer.
//
bool cancel_timer(Pj_Event_Handler *handler)
{
return pj_timer_heap_cancel(th_, &handler->timer_) == 1;
}
//
// Handle events.
//
int handle_events(Pj_Time_Val *max_timeout)
{
Pj_Time_Val timeout(0, 0);
int timer_count;
timer_count = pj_timer_heap_poll( th_, &timeout );
if (timeout.get_sec() < 0)
timeout.sec = PJ_MAXINT32;
/* If caller specifies maximum time to wait, then compare the value
* with the timeout to wait from timer, and use the minimum value.
*/
if (max_timeout && timeout >= *max_timeout) {
timeout = *max_timeout;
}
/* Poll events in ioqueue. */
int ioqueue_count;
ioqueue_count = pj_ioqueue_poll(ioq_, &timeout);
if (ioqueue_count < 0)
return ioqueue_count;
return ioqueue_count + timer_count;
}
//
// Get the internal ioqueue object.
//
pj_ioqueue_t *get_io_queue()
{
return ioq_;
}
//
// Get the internal timer heap object.
//
pj_timer_heap_t *get_timer_heap()
{
return th_;
}
private:
pj_ioqueue_t *ioq_;
pj_timer_heap_t *th_;
pj_ioqueue_callback cb_;
static bool schedule_timer( pj_timer_heap_t *timer,
Pj_Event_Handler *handler,
const Pj_Time_Val &delay,
int id=-1)
{
handler->timer_.id = id;
return pj_timer_heap_schedule(timer, &handler->timer_, &delay) == 0;
}
//
// Static read completion callback.
//
static void read_complete_cb( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_read)
{
Pj_Event_Handler *handler =
(Pj_Event_Handler*) pj_ioqueue_get_user_data(key);
handler->on_read_complete((Pj_Async_Op*)op_key, bytes_read);
}
//
// Static write completion callback.
//
static void write_complete_cb(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_sent)
{
Pj_Event_Handler *handler =
(Pj_Event_Handler*) pj_ioqueue_get_user_data(key);
handler->on_write_complete((Pj_Async_Op*)op_key, bytes_sent);
}
//
// Static accept completion callback.
//
static void accept_complete_cb(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_sock_t new_sock,
pj_status_t status)
{
Pj_Event_Handler *handler =
(Pj_Event_Handler*) pj_ioqueue_get_user_data(key);
handler->on_accept_complete((Pj_Async_Op*)op_key, new_sock, status);
}
//
// Static connect completion callback.
//
static void connect_complete_cb(pj_ioqueue_key_t *key,
pj_status_t status)
{
Pj_Event_Handler *handler =
(Pj_Event_Handler*) pj_ioqueue_get_user_data(key);
handler->on_connect_complete(status);
}
};
#endif /* __PJPP_PROACTOR_HPP__ */

245
GSMGateway/app/src/main/cpp/pj++/scanner.hpp Normal file
View File

@@ -0,0 +1,245 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_SCANNER_HPP__
#define __PJPP_SCANNER_HPP__
#include <pjlib-util/scanner.h>
#include <pj++/string.hpp>
class Pj_Cis;
class Pj_Cis_Buffer;
class Pj_Scanner;
class Pj_Cis_Buffer
{
friend class Pj_Cis;
public:
Pj_Cis_Buffer()
{
pj_cis_buf_init(&buf_);
}
private:
pj_cis_buf_t buf_;
};
class Pj_Cis
{
friend class Pj_Scanner;
public:
Pj_Cis(Pj_Cis_Buffer *buf)
{
pj_cis_init(&buf->buf_, &cis_);
}
Pj_Cis(const Pj_Cis &rhs)
{
pj_cis_dup(&cis_, (pj_cis_t*)&rhs.cis_);
}
void add_range(int start, int end)
{
pj_cis_add_range(&cis_, start, end);
}
void add_alpha()
{
pj_cis_add_alpha(&cis_);
}
void add_num()
{
pj_cis_add_num(&cis_);
}
void add_str(const char *str)
{
pj_cis_add_str(&cis_, str);
}
void add_cis(const Pj_Cis &rhs)
{
pj_cis_add_cis(&cis_, &rhs.cis_);
}
void del_range(int start, int end)
{
pj_cis_del_range(&cis_, start, end);
}
void del_str(const char *str)
{
pj_cis_del_str(&cis_, str);
}
void invert()
{
pj_cis_invert(&cis_);
}
bool match(int c) const
{
return pj_cis_match(&cis_, c) != 0;
}
private:
pj_cis_t cis_;
};
class Pj_Scanner
{
public:
Pj_Scanner() {}
enum
{
SYNTAX_ERROR = 101
};
static void syntax_error_handler_throw_pj(pj_scanner *);
typedef pj_scan_state State;
void init(char *buf, int len, unsigned options=PJ_SCAN_AUTOSKIP_WS,
pj_syn_err_func_ptr callback = &syntax_error_handler_throw_pj)
{
pj_scan_init(&scanner_, buf, len, options, callback);
}
void fini()
{
pj_scan_fini(&scanner_);
}
int eof() const
{
return pj_scan_is_eof(&scanner_);
}
int peek_char() const
{
return *scanner_.curptr;
}
int peek(const Pj_Cis *cis, Pj_String *out)
{
return pj_scan_peek(&scanner_, &cis->cis_, out);
}
int peek_n(pj_size_t len, Pj_String *out)
{
return pj_scan_peek_n(&scanner_, len, out);
}
int peek_until(const Pj_Cis *cis, Pj_String *out)
{
return pj_scan_peek_until(&scanner_, &cis->cis_, out);
}
void get(const Pj_Cis *cis, Pj_String *out)
{
pj_scan_get(&scanner_, &cis->cis_, out);
}
void get_n(unsigned N, Pj_String *out)
{
pj_scan_get_n(&scanner_, N, out);
}
int get_char()
{
return pj_scan_get_char(&scanner_);
}
void get_quote(int begin_quote, int end_quote, Pj_String *out)
{
pj_scan_get_quote(&scanner_, begin_quote, end_quote, out);
}
void get_newline()
{
pj_scan_get_newline(&scanner_);
}
void get_until(const Pj_Cis *cis, Pj_String *out)
{
pj_scan_get_until(&scanner_, &cis->cis_, out);
}
void get_until_ch(int until_ch, Pj_String *out)
{
pj_scan_get_until_ch(&scanner_, until_ch, out);
}
void get_until_chr(const char *spec, Pj_String *out)
{
pj_scan_get_until_chr(&scanner_, spec, out);
}
void advance_n(unsigned N, bool skip_ws=true)
{
pj_scan_advance_n(&scanner_, N, skip_ws);
}
int strcmp(const char *s, int len)
{
return pj_scan_strcmp(&scanner_, s, len);
}
int stricmp(const char *s, int len)
{
return pj_scan_stricmp(&scanner_, s, len);
}
void skip_ws()
{
pj_scan_skip_whitespace(&scanner_);
}
void save_state(State *state) const
{
pj_scan_save_state(&scanner_, state);
}
void restore_state(State *state)
{
pj_scan_restore_state(&scanner_, state);
}
int get_pos_line() const
{
return scanner_.line;
}
int get_pos_col() const
{
return pj_scan_get_col(&scanner_);
}
private:
pj_scanner scanner_;
};
#endif /* __PJPP_SCANNER_HPP__ */

443
GSMGateway/app/src/main/cpp/pj++/sock.hpp Normal file
View File

@@ -0,0 +1,443 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_SOCK_HPP__
#define __PJPP_SOCK_HPP__
#include <pj/sock.h>
#include <pj/string.h>
class Pj_Event_Handler;
//
// Base class for address.
//
class Pj_Addr
{
};
//
// Internet address.
//
class Pj_Inet_Addr : public pj_sockaddr_in, public Pj_Addr
{
public:
//
// Get port number.
//
pj_uint16_t get_port_number() const
{
return pj_sockaddr_in_get_port(this);
}
//
// Set port number.
//
void set_port_number(pj_uint16_t port)
{
sin_family = PJ_AF_INET;
pj_sockaddr_in_set_port(this, port);
}
//
// Get IP address.
//
pj_uint32_t get_ip_address() const
{
return pj_sockaddr_in_get_addr(this).s_addr;
}
//
// Get address string.
//
const char *get_address() const
{
return pj_inet_ntoa(sin_addr);
}
//
// Set IP address.
//
void set_ip_address(pj_uint32_t addr)
{
sin_family = PJ_AF_INET;
pj_sockaddr_in_set_addr(this, addr);
}
//
// Set address.
//
pj_status_t set_address(const pj_str_t *addr)
{
return pj_sockaddr_in_set_str_addr(this, addr);
}
//
// Set address.
//
pj_status_t set_address(const char *addr)
{
pj_str_t s;
return pj_sockaddr_in_set_str_addr(this, pj_cstr(&s, addr));
}
//
// Compare for equality.
//
bool operator==(const Pj_Inet_Addr &rhs) const
{
return sin_family == rhs.sin_family &&
sin_addr.s_addr == rhs.sin_addr.s_addr &&
sin_port == rhs.sin_port;
}
private:
//
// Dummy length used in pj_ioqueue_recvfrom() etc
//
friend class Pj_Event_Handler;
friend class Pj_Socket;
friend class Pj_Sock_Stream;
friend class Pj_Sock_Dgram;
int addrlen_;
};
//
// Socket base class.
//
// Note:
// socket will not automatically be closed on destructor.
//
class Pj_Socket
{
public:
//
// Default constructor.
//
Pj_Socket()
: sock_(PJ_INVALID_SOCKET)
{
}
//
// Initialize from a socket handle.
//
explicit Pj_Socket(pj_sock_t sock)
: sock_(sock)
{
}
//
// Copy constructor.
//
Pj_Socket(const Pj_Socket &rhs)
: sock_(rhs.sock_)
{
}
//
// Destructor will not close the socket.
// You must call close() explicitly.
//
~Pj_Socket()
{
}
//
// Set socket handle.
//
void set_handle(pj_sock_t sock)
{
sock_ = sock;
}
//
// Get socket handle.
//
pj_sock_t get_handle() const
{
return sock_;
}
//
// Get socket handle.
//
pj_sock_t& get_handle()
{
return sock_;
}
//
// See if the socket is valid.
//
bool is_valid() const
{
return sock_ != PJ_INVALID_SOCKET;
}
//
// Create the socket.
//
pj_status_t create(int af, int type, int proto)
{
return pj_sock_socket(af, type, proto, &sock_);
}
//
// Bind socket.
//
pj_status_t bind(const Pj_Inet_Addr &addr)
{
return pj_sock_bind(sock_, &addr, sizeof(Pj_Inet_Addr));
}
//
// Close socket.
//
pj_status_t close()
{
pj_sock_close(sock_);
}
//
// Get peer socket name.
//
pj_status_t getpeername(Pj_Inet_Addr *addr)
{
return pj_sock_getpeername(sock_, addr, &addr->addrlen_);
}
//
// getsockname
//
pj_status_t getsockname(Pj_Inet_Addr *addr)
{
return pj_sock_getsockname(sock_, addr, &addr->addrlen_);
}
//
// getsockopt.
//
pj_status_t getsockopt(pj_uint16_t level, pj_uint16_t optname,
void *optval, int *optlen)
{
return pj_sock_getsockopt(sock_, level, optname, optval, optlen);
}
//
// setsockopt
//
pj_status_t setsockopt(pj_uint16_t level, pj_uint16_t optname,
const void *optval, int optlen)
{
return pj_sock_setsockopt(sock_, level, optname, optval, optlen);
}
//
// receive data.
//
pj_ssize_t recv(void *buf, pj_size_t len, int flag = 0)
{
pj_ssize_t bytes = len;
if (pj_sock_recv(sock_, buf, &bytes, flag) != PJ_SUCCESS)
return -1;
return bytes;
}
//
// send data.
//
pj_ssize_t send(const void *buf, pj_ssize_t len, int flag = 0)
{
pj_ssize_t bytes = len;
if (pj_sock_send(sock_, buf, &bytes, flag) != PJ_SUCCESS)
return -1;
return bytes;
}
//
// connect.
//
pj_status_t connect(const Pj_Inet_Addr &addr)
{
return pj_sock_connect(sock_, &addr, sizeof(Pj_Inet_Addr));
}
//
// assignment.
//
Pj_Socket &operator=(const Pj_Socket &rhs)
{
sock_ = rhs.sock_;
return *this;
}
protected:
friend class Pj_Event_Handler;
pj_sock_t sock_;
};
#if PJ_HAS_TCP
//
// Stream socket.
//
class Pj_Sock_Stream : public Pj_Socket
{
public:
//
// Default constructor.
//
Pj_Sock_Stream()
{
}
//
// Initialize from a socket handle.
//
explicit Pj_Sock_Stream(pj_sock_t sock)
: Pj_Socket(sock)
{
}
//
// Copy constructor.
//
Pj_Sock_Stream(const Pj_Sock_Stream &rhs) : Pj_Socket(rhs)
{
}
//
// Assignment.
//
Pj_Sock_Stream &operator=(const Pj_Sock_Stream &rhs)
{
sock_ = rhs.sock_;
return *this;
}
//
// listen()
//
pj_status_t listen(int backlog = 5)
{
return pj_sock_listen(sock_, backlog);
}
//
// blocking accept()
//
Pj_Sock_Stream accept(Pj_Inet_Addr *remote_addr = NULL)
{
pj_sock_t newsock;
int *addrlen = remote_addr ? &remote_addr->addrlen_ : NULL;
pj_status_t status;
status = pj_sock_accept(sock_, &newsock, remote_addr, addrlen);
if (status != PJ_SUCCESS)
return Pj_Sock_Stream(-1);
return Pj_Sock_Stream(newsock);
}
//
// shutdown()
//
pj_status_t shutdown(int how = PJ_SHUT_RDWR)
{
return pj_sock_shutdown(sock_, how);
}
};
#endif
//
// Datagram socket.
//
class Pj_Sock_Dgram : public Pj_Socket
{
public:
//
// Default constructor.
//
Pj_Sock_Dgram()
{
}
//
// Initialize from a socket handle.
//
explicit Pj_Sock_Dgram(pj_sock_t sock)
: Pj_Socket(sock)
{
}
//
// Copy constructor.
//
Pj_Sock_Dgram(const Pj_Sock_Dgram &rhs)
: Pj_Socket(rhs)
{
}
//
// Assignment.
//
Pj_Sock_Dgram &operator=(const Pj_Sock_Dgram &rhs)
{
Pj_Socket::operator =(rhs);
return *this;
}
//
// recvfrom()
//
pj_ssize_t recvfrom( void *buf, pj_size_t len, int flag = 0,
Pj_Inet_Addr *fromaddr = NULL)
{
pj_ssize_t bytes = len;
int *addrlen = fromaddr ? &fromaddr->addrlen_ : NULL;
if (pj_sock_recvfrom( sock_, buf, &bytes, flag,
fromaddr, addrlen) != PJ_SUCCESS)
{
return -1;
}
return bytes;
}
//
// sendto()
//
pj_ssize_t sendto( const void *buf, pj_size_t len, int flag,
const Pj_Inet_Addr &addr)
{
pj_ssize_t bytes = len;
if (pj_sock_sendto( sock_, buf, &bytes, flag,
&addr, sizeof(pj_sockaddr_in)) != PJ_SUCCESS)
{
return -1;
}
return bytes;
}
};
#endif /* __PJPP_SOCK_HPP__ */

467
GSMGateway/app/src/main/cpp/pj++/string.hpp Normal file
View File

@@ -0,0 +1,467 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_STRING_HPP__
#define __PJPP_STRING_HPP__
#include <pj/string.h>
#include <pj++/pool.hpp>
#include <pj/assert.h>
//
// String wrapper class for pj_str_t.
//
class Pj_String : public pj_str_t
{
public:
//
// Default constructor.
//
Pj_String()
{
pj_assert(sizeof(Pj_String) == sizeof(pj_str_t));
ptr=NULL;
slen=0;
}
//
// Construct the buffer from a char* (use with care)
//
Pj_String(char *str)
{
set(str);
}
//
// Construct from a const char*.
//
Pj_String(Pj_Pool &pool, const char *src)
{
set(pool, src);
}
//
// Construct from pj_str_t&.
//
explicit Pj_String(pj_str_t &s)
{
ptr = s.ptr;
slen = s.slen;
}
//
// Construct from const pj_str_t& (use with care!).
//
explicit Pj_String(const pj_str_t &s)
{
ptr = (char*)s.ptr;
slen = s.slen;
}
//
// Construct by copying from const pj_str_t*.
//
Pj_String(Pj_Pool &pool, const pj_str_t *s)
{
set(pool, s);
}
//
// Construct by copying from Pj_String
//
Pj_String(Pj_Pool &pool, const Pj_String &rhs)
{
set(pool, rhs);
}
//
// Construct from another Pj_String, use with care!
//
explicit Pj_String(const Pj_String &rhs)
{
ptr = rhs.ptr;
slen = rhs.slen;
}
//
// Construct from a char* and a length.
//
Pj_String(char *str, pj_size_t len)
{
set(str, len);
}
//
// Construct from pair of pointer.
//
Pj_String(char *begin, char *end)
{
pj_strset3(this, begin, end);
}
//
// You can cast Pj_String to pj_str_t*
//
operator pj_str_t*()
{
return this;
}
//
// You can cast const Pj_String to const pj_str_t*
//
operator const pj_str_t*() const
{
return this;
}
//
// Get the length of the string.
//
pj_size_t length() const
{
return pj_strlen(this);
}
//
// Get the length of the string.
//
pj_size_t size() const
{
return length();
}
//
// Get the string buffer.
//
const char *buf() const
{
return ptr;
}
//
// Initialize buffer from char*.
//
void set(char *str)
{
pj_strset2(this, str);
}
//
// Initialize by copying from a const char*.
//
void set(Pj_Pool &pool, const char *s)
{
pj_strdup2(pool, this, s);
}
//
// Initialize from pj_str_t*.
//
void set(pj_str_t *s)
{
pj_strassign(this, s);
}
//
// Initialize by copying from const pj_str_t*.
//
void set(Pj_Pool &pool, const pj_str_t *s)
{
pj_strdup(pool, this, s);
}
//
// Initialize from char* and length.
//
void set(char *str, pj_size_t len)
{
pj_strset(this, str, len);
}
//
// Initialize from pair of pointers.
//
void set(char *begin, char *end)
{
pj_strset3(this, begin, end);
}
//
// Initialize from other Pj_String.
//
void set(Pj_String &rhs)
{
pj_strassign(this, &rhs);
}
//
// Initialize by copying from a Pj_String*.
//
void set(Pj_Pool &pool, const Pj_String *s)
{
pj_strdup(pool, this, s);
}
//
// Initialize by copying from other Pj_String.
//
void set(Pj_Pool &pool, const Pj_String &s)
{
pj_strdup(pool, this, &s);
}
//
// Copy the contents of other string.
//
void strcpy(const pj_str_t *s)
{
pj_strcpy(this, s);
}
//
// Copy the contents of other string.
//
void strcpy(const Pj_String &rhs)
{
pj_strcpy(this, &rhs);
}
//
// Copy the contents of other string.
//
void strcpy(const char *s)
{
pj_strcpy2(this, s);
}
//
// Compare string.
//
int strcmp(const char *s) const
{
return pj_strcmp2(this, s);
}
//
// Compare string.
//
int strcmp(const pj_str_t *s) const
{
return pj_strcmp(this, s);
}
//
// Compare string.
//
int strcmp(const Pj_String &rhs) const
{
return pj_strcmp(this, &rhs);
}
//
// Compare string.
//
int strncmp(const char *s, pj_size_t len) const
{
return pj_strncmp2(this, s, len);
}
//
// Compare string.
//
int strncmp(const pj_str_t *s, pj_size_t len) const
{
return pj_strncmp(this, s, len);
}
//
// Compare string.
//
int strncmp(const Pj_String &rhs, pj_size_t len) const
{
return pj_strncmp(this, &rhs, len);
}
//
// Compare string.
//
int stricmp(const char *s) const
{
return pj_stricmp2(this, s);
}
//
// Compare string.
//
int stricmp(const pj_str_t *s) const
{
return pj_stricmp(this, s);
}
//
// Compare string.
//
int stricmp(const Pj_String &rhs) const
{
return stricmp(&rhs);
}
//
// Compare string.
//
int strnicmp(const char *s, pj_size_t len) const
{
return pj_strnicmp2(this, s, len);
}
//
// Compare string.
//
int strnicmp(const pj_str_t *s, pj_size_t len) const
{
return pj_strnicmp(this, s, len);
}
//
// Compare string.
//
int strnicmp(const Pj_String &rhs, pj_size_t len) const
{
return strnicmp(&rhs, len);
}
//
// Compare contents for equality.
//
bool operator==(const char *s) const
{
return strcmp(s) == 0;
}
//
// Compare contents for equality.
//
bool operator==(const pj_str_t *s) const
{
return strcmp(s) == 0;
}
//
// Compare contents for equality.
//
bool operator==(const Pj_String &rhs) const
{
return pj_strcmp(this, &rhs) == 0;
}
//
// Assign from char*
//
Pj_String& operator=(char *s)
{
set(s);
return *this;
}
///
// Assign from another Pj_String, use with care!
//
Pj_String& operator=(const Pj_String &rhs)
{
ptr = rhs.ptr;
slen = rhs.slen;
return *this;
}
//
// Find a character in the string.
//
char *strchr(int chr)
{
return pj_strchr(this, chr);
}
//
// Find a character in the string.
//
char *find(int chr)
{
return strchr(chr);
}
//
// Concatenate string.
//
void strcat(const Pj_String &rhs)
{
pj_strcat(this, &rhs);
}
//
// Left trim.
//
void ltrim()
{
pj_strltrim(this);
}
//
// Right trim.
//
void rtrim()
{
pj_strrtrim(this);
}
//
// Left and right trim.
//
void trim()
{
pj_strtrim(this);
}
//
// Convert to unsigned long.
//
unsigned long to_ulong() const
{
return pj_strtoul(this);
}
//
// Convert from unsigned long.
//
void from_ulong(unsigned long value)
{
slen = pj_utoa(value, ptr);
}
//
// Convert from unsigned long with padding.
//
void from_ulong_with_pad(unsigned long value, int min_dig=0, int pad=' ')
{
slen = pj_utoa_pad(value, ptr, min_dig, pad);
}
};
#endif /* __PJPP_STRING_HPP__ */

197
GSMGateway/app/src/main/cpp/pj++/timer.hpp Normal file
View File

@@ -0,0 +1,197 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_TIMER_HPP__
#define __PJPP_TIMER_HPP__
#include <pj/timer.h>
#include <pj++/types.hpp>
#include <pj/assert.h>
#include <pj++/lock.hpp>
class Pj_Timer_Heap;
//////////////////////////////////////////////////////////////////////////////
// Timer entry.
//
// How to use:
// Derive class from Pj_Timer_Entry and override on_timeout().
// Scheduler timer in Pj_Timer_Heap.
//
class Pj_Timer_Entry : public Pj_Object
{
friend class Pj_Timer_Heap;
public:
//
// Default constructor.
//
Pj_Timer_Entry()
{
entry_.user_data = this;
entry_.cb = &timer_heap_callback;
}
//
// Destructor, do nothing.
//
~Pj_Timer_Entry()
{
}
//
// Override this to get the timeout notification.
//
virtual void on_timeout(int id) = 0;
private:
pj_timer_entry entry_;
static void timer_heap_callback(pj_timer_heap_t*, pj_timer_entry *e)
{
Pj_Timer_Entry *entry = (Pj_Timer_Entry*) e->user_data;
entry->on_timeout(e->id);
}
};
//////////////////////////////////////////////////////////////////////////////
// Timer heap.
//
class Pj_Timer_Heap : public Pj_Object
{
public:
//
// Default constructor.
//
Pj_Timer_Heap()
: ht_(NULL)
{
}
//
// Construct timer heap.
//
Pj_Timer_Heap(Pj_Pool *pool, pj_size_t initial_count)
: ht_(NULL)
{
create(pool, initial_count);
}
//
// Destructor.
//
~Pj_Timer_Heap()
{
destroy();
}
//
// Create
//
pj_status_t create(Pj_Pool *pool, pj_size_t initial_count)
{
destroy();
return pj_timer_heap_create(pool->pool_(), initial_count, &ht_);
}
//
// Destroy
//
void destroy()
{
if (ht_) {
pj_timer_heap_destroy(ht_);
ht_ = NULL;
}
}
//
// Get pjlib compatible timer heap object.
//
pj_timer_heap_t *get_timer_heap()
{
return ht_;
}
//
// Set the lock object.
//
void set_lock( Pj_Lock *lock, bool auto_delete )
{
pj_timer_heap_set_lock( ht_, lock->pj_lock_t_(), auto_delete);
}
//
// Set maximum number of timed out entries to be processed per poll.
//
unsigned set_max_timed_out_per_poll(unsigned count)
{
return pj_timer_heap_set_max_timed_out_per_poll(ht_, count);
}
//
// Schedule a timer.
//
bool schedule( Pj_Timer_Entry *ent, const Pj_Time_Val &delay,
int id)
{
ent->entry_.id = id;
return pj_timer_heap_schedule(ht_, &ent->entry_, &delay) == 0;
}
//
// Cancel a timer.
//
bool cancel(Pj_Timer_Entry *ent)
{
return pj_timer_heap_cancel(ht_, &ent->entry_) == 1;
}
//
// Get current number of timers
//
pj_size_t count()
{
return pj_timer_heap_count(ht_);
}
//
// Get the earliest time.
// Return false if no timer is found.
//
bool earliest_time(Pj_Time_Val *t)
{
return pj_timer_heap_earliest_time(ht_, t) == PJ_SUCCESS;
}
//
// Poll the timer.
// Return number of timed out entries has been called.
//
unsigned poll(Pj_Time_Val *next_delay = NULL)
{
return pj_timer_heap_poll(ht_, next_delay);
}
private:
pj_timer_heap_t *ht_;
};
#endif /* __PJPP_TIMER_HPP__ */

128
GSMGateway/app/src/main/cpp/pj++/tree.hpp Normal file
View File

@@ -0,0 +1,128 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_TREE_HPP__
#define __PJPP_TREE_HPP__
#include <pj/rbtree.h>
//
// Tree.
//
class PJ_Tree
{
public:
typedef pj_rbtree_comp Comp;
class iterator;
class reverse_iterator;
class Node : private pj_rbtree_node
{
friend class PJ_Tree;
friend class iterator;
friend class reverse_iterator;
public:
Node() {}
explicit Node(void *data) { user_data = data; }
void set_user_data(void *data) { user_data = data; }
void *get_user_data() const { return user_data; }
};
class iterator
{
public:
iterator() {}
iterator(const iterator &rhs) : tr_(rhs.tr_), nd_(rhs.nd_) {}
iterator(pj_rbtree *tr, pj_rbtree_node *nd) : tr_(tr), nd_(nd) {}
Node *operator*() { return (Node*)nd_; }
bool operator==(const iterator &rhs) const { return tr_==rhs.tr_ && nd_==rhs.nd_; }
iterator &operator=(const iterator &rhs) { tr_=rhs.tr_; nd_=rhs.nd_; return *this; }
void operator++() { nd_=pj_rbtree_next(tr_, nd_); }
void operator--() { nd_=pj_rbtree_prev(tr_, nd_); }
protected:
pj_rbtree *tr_;
pj_rbtree_node *nd_;
};
class reverse_iterator : public iterator
{
public:
reverse_iterator() {}
reverse_iterator(const reverse_iterator &it) : iterator(it) {}
reverse_iterator(pj_rbtree *t, pj_rbtree_node *n) : iterator(t, n) {}
reverse_iterator &operator=(const reverse_iterator &rhs) { iterator::operator=(rhs); return *this; }
Node *operator*() { return (Node*)nd_; }
bool operator==(const reverse_iterator &rhs) const { return iterator::operator==(rhs); }
void operator++() { nd_=pj_rbtree_prev(tr_, nd_); }
void operator--() { nd_=pj_rbtree_next(tr_, nd_); }
};
explicit PJ_Tree(Comp *comp) { pj_rbtree_init(&t_, comp); }
iterator begin()
{
return iterator(&t_, pj_rbtree_first(&t_));
}
iterator end()
{
return iterator(&t_, NULL);
}
reverse_iterator rbegin()
{
return reverse_iterator(&t_, pj_rbtree_last(&t_));
}
reverse_iterator rend()
{
return reverse_iterator(&t_, NULL);
}
bool insert(Node *node)
{
return pj_rbtree_insert(&t_, node)==0 ? true : false;
}
Node *find(const void *key)
{
return (Node*)pj_rbtree_find(&t_, key);
}
Node *erase(Node *node)
{
return (Node*)pj_rbtree_erase(&t_, node);
}
unsigned max_height(Node *node=NULL)
{
return pj_rbtree_max_height(&t_, node);
}
unsigned min_height(Node *node=NULL)
{
return pj_rbtree_min_height(&t_, node);
}
private:
pj_rbtree t_;
};
#endif /* __PJPP_TREE_HPP__ */

174
GSMGateway/app/src/main/cpp/pj++/types.hpp Normal file
View File

@@ -0,0 +1,174 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJPP_TYPES_HPP__
#define __PJPP_TYPES_HPP__
#include <pj/types.h>
class Pj_Pool;
class Pj_Socket ;
class Pj_Lock;
//
// PJLIB initializer.
//
class Pjlib
{
public:
Pjlib()
{
pj_init();
}
};
//
// Class Pj_Object is declared in pool.hpp
//
//
// Time value wrapper.
//
class Pj_Time_Val : public pj_time_val
{
public:
Pj_Time_Val()
{
}
Pj_Time_Val(long init_sec, long init_msec)
{
sec = init_sec;
msec = init_msec;
}
Pj_Time_Val(const Pj_Time_Val &rhs)
{
sec=rhs.sec;
msec=rhs.msec;
}
explicit Pj_Time_Val(const pj_time_val &tv)
{
sec = tv.sec;
msec = tv.msec;
}
long get_sec() const
{
return sec;
}
long get_msec() const
{
return msec;
}
void set_sec (long s)
{
sec = s;
}
void set_msec(long ms)
{
msec = ms;
normalize();
}
long to_msec() const
{
return PJ_TIME_VAL_MSEC((*this));
}
bool operator == (const Pj_Time_Val &rhs) const
{
return PJ_TIME_VAL_EQ((*this), rhs);
}
bool operator > (const Pj_Time_Val &rhs) const
{
return PJ_TIME_VAL_GT((*this), rhs);
}
bool operator >= (const Pj_Time_Val &rhs) const
{
return PJ_TIME_VAL_GTE((*this), rhs);
}
bool operator < (const Pj_Time_Val &rhs) const
{
return PJ_TIME_VAL_LT((*this), rhs);
}
bool operator <= (const Pj_Time_Val &rhs) const
{
return PJ_TIME_VAL_LTE((*this), rhs);
}
Pj_Time_Val & operator = (const Pj_Time_Val &rhs)
{
sec = rhs.sec;
msec = rhs.msec;
return *this;
}
Pj_Time_Val & operator += (const Pj_Time_Val &rhs)
{
PJ_TIME_VAL_ADD((*this), rhs);
return *this;
}
Pj_Time_Val & operator -= (const Pj_Time_Val &rhs)
{
PJ_TIME_VAL_SUB((*this), rhs);
return *this;
}
/* Must include os.hpp to use these, otherwise unresolved in linking */
inline pj_status_t gettimeofday();
inline pj_parsed_time decode();
inline pj_status_t encode(const pj_parsed_time *pt);
inline pj_status_t to_gmt();
inline pj_status_t to_local();
private:
void normalize()
{
pj_time_val_normalize(this);
}
};
//
// Macro to declare common object comparison operators.
//
#define PJ_DECLARE_OPERATORS(rhs_type) \
bool operator!=(rhs_type rhs) const { \
return !operator==(rhs); } \
bool operator<=(rhs_type rhs) const { \
return operator<(rhs) || operator==(rhs); } \
bool operator>(rhs_type rhs) const { \
return !operator<=(rhs); } \
bool operator>=(rhs_type rhs) const { \
return !operator<(rhs); }
#endif /* __PJPP_TYPES_HPP__ */

598
GSMGateway/app/src/main/cpp/pj/activesock.h Normal file
View File

@@ -0,0 +1,598 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_ASYNCSOCK_H__
#define __PJ_ASYNCSOCK_H__
/**
* @file activesock.h
* @brief Active socket
*/
#include <pj/ioqueue.h>
#include <pj/sock.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_ACTIVESOCK Active socket I/O
* @brief Active socket performs active operations on socket.
* @ingroup PJ_IO
* @{
*
* Active socket is a higher level abstraction to the ioqueue. It provides
* automation to socket operations which otherwise would have to be done
* manually by the applications. For example with socket recv(), recvfrom(),
* and accept() operations, application only needs to invoke these
* operation once, and it will be notified whenever data or incoming TCP
* connection (in the case of accept()) arrives.
*/
/**
* This opaque structure describes the active socket.
*/
typedef struct pj_activesock_t pj_activesock_t;
/**
* This structure contains the callbacks to be called by the active socket.
*/
typedef struct pj_activesock_cb
{
/**
* This callback is called when a data arrives as the result of
* pj_activesock_start_read().
*
* @param asock The active socket.
* @param data The buffer containing the new data, if any. If
* the status argument is non-PJ_SUCCESS, this
* argument may be NULL.
* @param size The length of data in the buffer.
* @param status The status of the read operation. This may contain
* non-PJ_SUCCESS for example when the TCP connection
* has been closed. In this case, the buffer may
* contain left over data from previous callback which
* the application may want to process.
* @param remainder If application wishes to leave some data in the
* buffer (common for TCP applications), it should
* move the remainder data to the front part of the
* buffer and set the remainder length here. The value
* of this parameter will be ignored for datagram
* sockets.
*
* @return PJ_TRUE if further read is desired, and PJ_FALSE
* when application no longer wants to receive data.
* Application may destroy the active socket in the
* callback and return PJ_FALSE here.
*/
pj_bool_t (*on_data_read)(pj_activesock_t *asock,
void *data,
pj_size_t size,
pj_status_t status,
pj_size_t *remainder);
/**
* This callback is called when a packet arrives as the result of
* pj_activesock_start_recvfrom().
*
* @param asock The active socket.
* @param data The buffer containing the packet, if any. If
* the status argument is non-PJ_SUCCESS, this
* argument will be set to NULL.
* @param size The length of packet in the buffer. If
* the status argument is non-PJ_SUCCESS, this
* argument will be set to zero.
* @param src_addr Source address of the packet.
* @param addr_len Length of the source address.
* @param status This contains
*
* @return PJ_TRUE if further read is desired, and PJ_FALSE
* when application no longer wants to receive data.
* Application may destroy the active socket in the
* callback and return PJ_FALSE here.
*/
pj_bool_t (*on_data_recvfrom)(pj_activesock_t *asock,
void *data,
pj_size_t size,
const pj_sockaddr_t *src_addr,
int addr_len,
pj_status_t status);
/**
* This callback is called when data has been sent.
*
* @param asock The active socket.
* @param send_key Key associated with the send operation.
* @param sent If value is positive non-zero it indicates the
* number of data sent. When the value is negative,
* it contains the error code which can be retrieved
* by negating the value (i.e. status=-sent).
*
* @return Application may destroy the active socket in the
* callback and return PJ_FALSE here.
*/
pj_bool_t (*on_data_sent)(pj_activesock_t *asock,
pj_ioqueue_op_key_t *send_key,
pj_ssize_t sent);
/**
* This callback is called when new connection arrives as the result
* of pj_activesock_start_accept(). If the status of accept operation is
* needed use on_accept_complete2 instead of this callback.
*
* @param asock The active socket.
* @param newsock The new incoming socket.
* @param src_addr The source address of the connection.
* @param addr_len Length of the source address.
*
* @return PJ_TRUE if further accept() is desired, and PJ_FALSE
* when application no longer wants to accept incoming
* connection. Application may destroy the active socket
* in the callback and return PJ_FALSE here.
*/
pj_bool_t (*on_accept_complete)(pj_activesock_t *asock,
pj_sock_t newsock,
const pj_sockaddr_t *src_addr,
int src_addr_len);
/**
* This callback is called when new connection arrives as the result
* of pj_activesock_start_accept().
*
* @param asock The active socket.
* @param newsock The new incoming socket.
* @param src_addr The source address of the connection.
* @param addr_len Length of the source address.
* @param status The status of the accept operation. This may contain
* non-PJ_SUCCESS for example when the TCP listener is in
* bad state for example on iOS platform after the
* application waking up from background.
*
* @return PJ_TRUE if further accept() is desired, and PJ_FALSE
* when application no longer wants to accept incoming
* connection. Application may destroy the active socket
* in the callback and return PJ_FALSE here.
*/
pj_bool_t (*on_accept_complete2)(pj_activesock_t *asock,
pj_sock_t newsock,
const pj_sockaddr_t *src_addr,
int src_addr_len,
pj_status_t status);
/**
* This callback is called when pending connect operation has been
* completed.
*
* @param asock The active socket.
* @param status The connection result. If connection has been
* successfully established, the status will contain
* PJ_SUCCESS.
*
* @return Application may destroy the active socket in the
* callback and return PJ_FALSE here.
*/
pj_bool_t (*on_connect_complete)(pj_activesock_t *asock,
pj_status_t status);
} pj_activesock_cb;
/**
* Settings that can be given during active socket creation. Application
* must initialize this structure with #pj_activesock_cfg_default().
*/
typedef struct pj_activesock_cfg
{
/**
* Optional group lock to be assigned to the ioqueue key.
*/
pj_grp_lock_t *grp_lock;
/**
* Number of concurrent asynchronous operations that is to be supported
* by the active socket. This value only affects socket receive and
* accept operations -- the active socket will issue one or more
* asynchronous read and accept operations based on the value of this
* field. Setting this field to more than one will allow more than one
* incoming data or incoming connections to be processed simultaneously
* on multiprocessor systems, when the ioqueue is polled by more than
* one threads.
*
* The default value is 1.
*/
unsigned async_cnt;
/**
* The ioqueue concurrency to be forced on the socket when it is
* registered to the ioqueue. See #pj_ioqueue_set_concurrency() for more
* info about ioqueue concurrency.
*
* When this value is -1, the concurrency setting will not be forced for
* this socket, and the socket will inherit the concurrency setting of
* the ioqueue. When this value is zero, the active socket will disable
* concurrency for the socket. When this value is +1, the active socket
* will enable concurrency for the socket.
*
* The default value is -1.
*/
int concurrency;
/**
* If this option is specified, the active socket will make sure that
* asynchronous send operation with stream oriented socket will only
* call the callback after all data has been sent. This means that the
* active socket will automatically resend the remaining data until
* all data has been sent.
*
* Please note that when this option is specified, it is possible that
* error is reported after partial data has been sent. Also setting
* this will disable the ioqueue concurrency for the socket.
*
* Default value is PJ_TRUE.
*/
pj_bool_t whole_data;
/**
* If this option is specified, set close-on-exec flag for socket.
* This option is only used by #pj_activesock_create_udp()
*
* Default value is PJ_TRUE.
*/
pj_bool_t sock_cloexec;
} pj_activesock_cfg;
/**
* Initialize the active socket configuration with the default values.
*
* @param cfg The configuration to be initialized.
*/
PJ_DECL(void) pj_activesock_cfg_default(pj_activesock_cfg *cfg);
/**
* Create the active socket for the specified socket. This will register
* the socket to the specified ioqueue.
*
* @param pool Pool to allocate memory from.
* @param sock The socket handle.
* @param sock_type Specify socket type, either pj_SOCK_DGRAM() or
* pj_SOCK_STREAM(). The active socket needs this
* information to handle connection closure for
* connection oriented sockets.
* @param ioqueue The ioqueue to use.
* @param opt Optional settings. When this setting is not specifed,
* the default values will be used.
* @param cb Pointer to structure containing application
* callbacks.
* @param user_data Arbitrary user data to be associated with this
* active socket.
* @param p_asock Pointer to receive the active socket instance.
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_create(pj_pool_t *pool,
pj_sock_t sock,
int sock_type,
const pj_activesock_cfg *opt,
pj_ioqueue_t *ioqueue,
const pj_activesock_cb *cb,
void *user_data,
pj_activesock_t **p_asock);
/**
* Create UDP socket descriptor, bind it to the specified address, and
* create the active socket for the socket descriptor.
*
* @param pool Pool to allocate memory from.
* @param addr Specifies the address family of the socket and the
* address where the socket should be bound to. If
* this argument is NULL, then AF_INET is assumed and
* the socket will be bound to any addresses and port.
* @param ioqueue The ioqueue.
* @param opt Optional settings. When this setting is not specifed,
* the default values will be used.
* @param cb Pointer to structure containing application
* callbacks.
* @param user_data Arbitrary user data to be associated with this
* active socket.
* @param p_asock Pointer to receive the active socket instance.
* @param bound_addr If this argument is specified, it will be filled with
* the bound address on return.
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_create_udp(pj_pool_t *pool,
const pj_sockaddr *addr,
const pj_activesock_cfg *opt,
pj_ioqueue_t *ioqueue,
const pj_activesock_cb *cb,
void *user_data,
pj_activesock_t **p_asock,
pj_sockaddr *bound_addr);
/**
* Close the active socket. This will unregister the socket from the
* ioqueue and ultimately close the socket.
*
* @param asock The active socket.
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_close(pj_activesock_t *asock);
#if (defined(PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT) && \
PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT!=0) || \
defined(DOXYGEN)
/**
* Set iPhone OS background mode setting. Setting to 1 will enable TCP
* active socket to receive incoming data when application is in the
* background. Setting to 0 will disable it. Default value of this
* setting is PJ_ACTIVESOCK_TCP_IPHONE_OS_BG.
*
* This API is only available if PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT
* is set to non-zero.
*
* @param asock The active socket.
* @param val The value of background mode setting.
*
*/
PJ_DECL(void) pj_activesock_set_iphone_os_bg(pj_activesock_t *asock,
int val);
/**
* Enable/disable support for iPhone OS background mode. This setting
* will apply globally and will affect any active sockets created
* afterwards, if you want to change the setting for a particular
* active socket, use #pj_activesock_set_iphone_os_bg() instead.
* By default, this setting is enabled.
*
* This API is only available if PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT
* is set to non-zero.
*
* @param val The value of global background mode setting.
*
*/
PJ_DECL(void) pj_activesock_enable_iphone_os_bg(pj_bool_t val);
#endif
/**
* Associate arbitrary data with the active socket. Application may
* inspect this data in the callbacks and associate it with higher
* level processing.
*
* @param asock The active socket.
* @param user_data The user data to be associated with the active
* socket.
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_set_user_data(pj_activesock_t *asock,
void *user_data);
/**
* Retrieve the user data previously associated with this active
* socket.
*
* @param asock The active socket.
*
* @return The user data.
*/
PJ_DECL(void*) pj_activesock_get_user_data(pj_activesock_t *asock);
/**
* Starts read operation on this active socket. This function will create
* \a async_cnt number of buffers (the \a async_cnt parameter was given
* in \a pj_activesock_create() function) where each buffer is \a buff_size
* long. The buffers are allocated from the specified \a pool. Once the
* buffers are created, it then issues \a async_cnt number of asynchronous
* \a recv() operations to the socket and returns back to caller. Incoming
* data on the socket will be reported back to application via the
* \a on_data_read() callback.
*
* Application only needs to call this function once to initiate read
* operations. Further read operations will be done automatically by the
* active socket when \a on_data_read() callback returns non-zero.
*
* @param asock The active socket.
* @param pool Pool used to allocate buffers for incoming data.
* @param buff_size The size of each buffer, in bytes.
* @param flags Flags to be given to pj_ioqueue_recv().
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_start_read(pj_activesock_t *asock,
pj_pool_t *pool,
unsigned buff_size,
pj_uint32_t flags);
/**
* Same as #pj_activesock_start_read(), except that the application
* supplies the buffers for the read operation so that the acive socket
* does not have to allocate the buffers.
*
* @param asock The active socket.
* @param pool Pool used to allocate buffers for incoming data.
* @param buff_size The size of each buffer, in bytes.
* @param readbuf Array of packet buffers, each has buff_size size.
* @param flags Flags to be given to pj_ioqueue_recv().
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_start_read2(pj_activesock_t *asock,
pj_pool_t *pool,
unsigned buff_size,
void *readbuf[],
pj_uint32_t flags);
/**
* Same as pj_activesock_start_read(), except that this function is used
* only for datagram sockets, and it will trigger \a on_data_recvfrom()
* callback instead.
*
* @param asock The active socket.
* @param pool Pool used to allocate buffers for incoming data.
* @param buff_size The size of each buffer, in bytes.
* @param flags Flags to be given to pj_ioqueue_recvfrom().
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_start_recvfrom(pj_activesock_t *asock,
pj_pool_t *pool,
unsigned buff_size,
pj_uint32_t flags);
/**
* Same as #pj_activesock_start_recvfrom() except that the recvfrom()
* operation takes the buffer from the argument rather than creating
* new ones.
*
* @param asock The active socket.
* @param pool Pool used to allocate buffers for incoming data.
* @param buff_size The size of each buffer, in bytes.
* @param readbuf Array of packet buffers, each has buff_size size.
* @param flags Flags to be given to pj_ioqueue_recvfrom().
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_start_recvfrom2(pj_activesock_t *asock,
pj_pool_t *pool,
unsigned buff_size,
void *readbuf[],
pj_uint32_t flags);
/**
* Send data using the socket.
*
* @param asock The active socket.
* @param send_key The operation key to send the data, which is useful
* if application wants to submit multiple pending
* send operations and want to track which exact data
* has been sent in the \a on_data_sent() callback.
* @param data The data to be sent. This data must remain valid
* until the data has been sent.
* @param size The size of the data.
* @param flags Flags to be given to pj_ioqueue_send().
*
*
* @return PJ_SUCCESS if data has been sent immediately, or
* PJ_EPENDING if data cannot be sent immediately. In
* this case the \a on_data_sent() callback will be
* called when data is actually sent. Any other return
* value indicates error condition.
*/
PJ_DECL(pj_status_t) pj_activesock_send(pj_activesock_t *asock,
pj_ioqueue_op_key_t *send_key,
const void *data,
pj_ssize_t *size,
unsigned flags);
/**
* Send datagram using the socket.
*
* @param asock The active socket.
* @param send_key The operation key to send the data, which is useful
* if application wants to submit multiple pending
* send operations and want to track which exact data
* has been sent in the \a on_data_sent() callback.
* @param data The data to be sent. This data must remain valid
* until the data has been sent.
* @param size The size of the data.
* @param flags Flags to be given to pj_ioqueue_send().
* @param addr The destination address.
* @param addr_len The length of the address.
*
* @return PJ_SUCCESS if data has been sent immediately, or
* PJ_EPENDING if data cannot be sent immediately. In
* this case the \a on_data_sent() callback will be
* called when data is actually sent. Any other return
* value indicates error condition.
*/
PJ_DECL(pj_status_t) pj_activesock_sendto(pj_activesock_t *asock,
pj_ioqueue_op_key_t *send_key,
const void *data,
pj_ssize_t *size,
unsigned flags,
const pj_sockaddr_t *addr,
int addr_len);
#if PJ_HAS_TCP
/**
* Starts asynchronous socket accept() operations on this active socket.
* Application must bind the socket before calling this function. This
* function will issue \a async_cnt number of asynchronous \a accept()
* operations to the socket and returns back to caller. Incoming
* connection on the socket will be reported back to application via the
* \a on_accept_complete() callback.
*
* Application only needs to call this function once to initiate accept()
* operations. Further accept() operations will be done automatically by
* the active socket when \a on_accept_complete() callback returns non-zero.
*
* @param asock The active socket.
* @param pool Pool used to allocate some internal data for the
* operation.
*
* @return PJ_SUCCESS if the operation has been successful,
* or the appropriate error code on failure.
*/
PJ_DECL(pj_status_t) pj_activesock_start_accept(pj_activesock_t *asock,
pj_pool_t *pool);
/**
* Starts asynchronous socket connect() operation for this socket. Once
* the connection is done (either successfully or not), the
* \a on_connect_complete() callback will be called.
*
* @param asock The active socket.
* @param pool The pool to allocate some internal data for the
* operation.
* @param remaddr Remote address.
* @param addr_len Length of the remote address.
*
* @return PJ_SUCCESS if connection can be established immediately,
* or PJ_EPENDING if connection cannot be established
* immediately. In this case the \a on_connect_complete()
* callback will be called when connection is complete.
* Any other return value indicates error condition.
*/
PJ_DECL(pj_status_t) pj_activesock_start_connect(pj_activesock_t *asock,
pj_pool_t *pool,
const pj_sockaddr_t *remaddr,
int addr_len);
#endif /* PJ_HAS_TCP */
/**
* @}
*/
PJ_END_DECL
#endif /* __PJ_ASYNCSOCK_H__ */

189
GSMGateway/app/src/main/cpp/pj/addr_resolv.h Normal file
View File

@@ -0,0 +1,189 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_ADDR_RESOLV_H__
#define __PJ_ADDR_RESOLV_H__
/**
* @file addr_resolv.h
* @brief IP address resolution.
*/
#include <pj/sock.h>
PJ_BEGIN_DECL
/**
* @defgroup pj_addr_resolve Network Address Resolution
* @ingroup PJ_IO
* @{
*
* This module provides function to resolve Internet address of the
* specified host name. To resolve a particular host name, application
* can just call #pj_gethostbyname().
*
* Example:
* <pre>
* ...
* pj_hostent he;
* pj_status_t rc;
* pj_str_t host = pj_str("host.example.com");
*
* rc = pj_gethostbyname( &host, &he);
* if (rc != PJ_SUCCESS) {
* char errbuf[80];
* pj_strerror( rc, errbuf, sizeof(errbuf));
* PJ_LOG(2,("sample", "Unable to resolve host, error=%s", errbuf));
* return rc;
* }
*
* // process address...
* addr.sin_addr.s_addr = *(pj_uint32_t*)he.h_addr;
* ...
* </pre>
*
* It's pretty simple really...
*/
/** This structure describes an Internet host address. */
typedef struct pj_hostent
{
char *h_name; /**< The official name of the host. */
char **h_aliases; /**< Aliases list. */
int h_addrtype; /**< Host address type. */
int h_length; /**< Length of address. */
char **h_addr_list; /**< List of addresses. */
} pj_hostent;
/** Shortcut to h_addr_list[0] */
#define h_addr h_addr_list[0]
/**
* This structure describes address information pj_getaddrinfo().
*/
typedef struct pj_addrinfo
{
char ai_canonname[PJ_MAX_HOSTNAME]; /**< Canonical name for host*/
pj_sockaddr ai_addr; /**< Binary address. */
} pj_addrinfo;
/**
* This function fills the structure of type pj_hostent for a given host name.
* For host resolution function that also works with IPv6, please see
* #pj_getaddrinfo().
*
* @param name Host name to resolve. Specifying IPv4 address here
* may fail on some platforms (e.g. Windows)
* @param he The pj_hostent structure to be filled. Note that
* the pointers in this structure points to temporary
* variables which value will be reset upon subsequent
* invocation.
*
* @return PJ_SUCCESS, or the appropriate error codes.
*/
PJ_DECL(pj_status_t) pj_gethostbyname(const pj_str_t *name, pj_hostent *he);
/**
* Resolve the primary IP address of local host.
*
* @param af The desired address family to query. Valid values
* are pj_AF_INET() or pj_AF_INET6().
* @param addr On successful resolution, the address family and address
* part of this socket address will be filled up with the host
* IP address, in network byte order. Other parts of the socket
* address are untouched.
*
* @return PJ_SUCCESS on success, or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_gethostip(int af, pj_sockaddr *addr);
/**
* Get the interface IP address to send data to the specified destination.
*
* @param af The desired address family to query. Valid values
* are pj_AF_INET() or pj_AF_INET6().
* @param dst The destination host.
* @param itf_addr On successful resolution, the address family and address
* part of this socket address will be filled up with the host
* IP address, in network byte order. Other parts of the socket
* address should be ignored.
* @param allow_resolve If \a dst may contain hostname (instead of IP
* address), specify whether hostname resolution should
* be performed. If not, default interface address will
* be returned.
* @param p_dst_addr If not NULL, it will be filled with the IP address of
* the destination host.
*
* @return PJ_SUCCESS on success, or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_getipinterface(int af,
const pj_str_t *dst,
pj_sockaddr *itf_addr,
pj_bool_t allow_resolve,
pj_sockaddr *p_dst_addr);
/**
* Get the IP address of the default interface. Default interface is the
* interface of the default route.
*
* @param af The desired address family to query. Valid values
* are pj_AF_INET() or pj_AF_INET6().
* @param addr On successful resolution, the address family and address
* part of this socket address will be filled up with the host
* IP address, in network byte order. Other parts of the socket
* address are untouched.
*
* @return PJ_SUCCESS on success, or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_getdefaultipinterface(int af,
pj_sockaddr *addr);
/**
* This function translates the name of a service location (for example,
* a host name) and returns a set of addresses and associated information
* to be used in creating a socket with which to address the specified
* service.
*
* @param af The desired address family to query. Valid values
* are pj_AF_INET(), pj_AF_INET6(), or pj_AF_UNSPEC().
* @param name Descriptive name or an address string, such as host
* name.
* @param count On input, it specifies the number of elements in
* \a ai array. On output, this will be set with the
* number of address informations found for the
* specified name.
* @param ai Array of address info to be filled with the information
* about the host.
*
* @return PJ_SUCCESS on success, or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_getaddrinfo(int af, const pj_str_t *name,
unsigned *count, pj_addrinfo ai[]);
/** @} */
PJ_END_DECL
#endif /* __PJ_ADDR_RESOLV_H__ */

95
GSMGateway/app/src/main/cpp/pj/array.h Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_ARRAY_H__
#define __PJ_ARRAY_H__
/**
* @file array.h
* @brief PJLIB Array helper.
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_ARRAY Array helper.
* @ingroup PJ_DS
* @{
*
* This module provides helper to manipulate array of elements of any size.
* It provides most used array operations such as insert, erase, and search.
*/
/**
* Insert value to the array at the given position, and rearrange the
* remaining nodes after the position.
*
* @param array the array.
* @param elem_size the size of the individual element.
* @param count the CURRENT number of elements in the array.
* @param pos the position where the new element is put.
* @param value the value to copy to the new element.
*/
PJ_DECL(void) pj_array_insert( void *array,
unsigned elem_size,
unsigned count,
unsigned pos,
const void *value);
/**
* Erase a value from the array at given position, and rearrange the remaining
* elements post the erased element.
*
* @param array the array.
* @param elem_size the size of the individual element.
* @param count the current number of elements in the array.
* @param pos the index/position to delete.
*/
PJ_DECL(void) pj_array_erase( void *array,
unsigned elem_size,
unsigned count,
unsigned pos);
/**
* Search the first value in the array according to matching function.
*
* @param array the array.
* @param elem_size the individual size of the element.
* @param count the number of elements.
* @param matching the matching function, which MUST return PJ_SUCCESS if
* the specified element match.
* @param result the pointer to the value found.
*
* @return PJ_SUCCESS if value is found, otherwise the error code.
*/
PJ_DECL(pj_status_t) pj_array_find( const void *array,
unsigned elem_size,
unsigned count,
pj_status_t (*matching)(const void *value),
void **result);
/**
* @}
*/
PJ_END_DECL
#endif /* __PJ_ARRAY_H__ */

84
GSMGateway/app/src/main/cpp/pj/assert.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_ASSERT_H__
#define __PJ_ASSERT_H__
/**
* @file assert.h
* @brief Assertion macro pj_assert().
*/
#include <pj/config.h>
#include <pj/compat/assert.h>
/**
* @defgroup pj_assert Assertion Macro
* @ingroup PJ_MISC
* @{
*
* Assertion and other helper macros for sanity checking.
*/
/**
* @hideinitializer
* Check during debug build that an expression is true. If the expression
* computes to false during run-time, then the program will stop at the
* offending statements.
* For release build, this macro will not do anything.
*
* @param expr The expression to be evaluated.
*/
#ifndef pj_assert
# define pj_assert(expr) assert(expr)
#endif
/**
* @hideinitializer
* If the expression yields false, assertion will be triggered
* and the current function will return with the specified return value.
*/
// #if defined(PJ_ENABLE_EXTRA_CHECK) && PJ_ENABLE_EXTRA_CHECK != 0
#define PJ_ASSERT_RETURN(expr,retval) \
do { \
if (!(expr)) { pj_assert(expr); return retval; } \
} while (0)
//#else
//# define PJ_ASSERT_RETURN(expr,retval) pj_assert(expr)
//#endif
/**
* @hideinitializer
* If the expression yields false, assertion will be triggered
* and @a exec_on_fail will be executed.
*/
//#if defined(PJ_ENABLE_EXTRA_CHECK) && PJ_ENABLE_EXTRA_CHECK != 0
#define PJ_ASSERT_ON_FAIL(expr,exec_on_fail) \
{ \
pj_assert(expr); \
if (!(expr)) exec_on_fail; \
}
//#else
//# define PJ_ASSERT_ON_FAIL(expr,exec_on_fail) pj_assert(expr)
//#endif
/** @} */
#endif /* __PJ_ASSERT_H__ */

36
GSMGateway/app/src/main/cpp/pj/compat/assert.h Normal file
View File

@@ -0,0 +1,36 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_ASSERT_H__
#define __PJ_COMPAT_ASSERT_H__
/**
* @file assert.h
* @brief Provides assert() macro.
*/
#if defined(PJ_HAS_ASSERT_H) && PJ_HAS_ASSERT_H != 0
# include <assert.h>
#else
# warning "assert() is not implemented"
# define assert(expr)
#endif
#endif /* __PJ_COMPAT_ASSERT_H__ */

57
GSMGateway/app/src/main/cpp/pj/compat/cc_armcc.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_CC_ARMCC_H__
#define __PJ_COMPAT_CC_ARMCC_H__
/**
* @file cc_armcc.h
* @brief Describes ARMCC compiler specifics.
*/
#ifndef __ARMCC__
# error "This file is only for armcc!"
#endif
#define PJ_CC_NAME "armcc"
#define PJ_CC_VER_1 (__ARMCC_VERSION/100000)
#define PJ_CC_VER_2 ((__ARMCC_VERSION%100000)/10000)
#define PJ_CC_VER_3 (__ARMCC_VERSION%10000)
#ifdef __cplusplus
# define PJ_INLINE_SPECIFIER inline
#else
# define PJ_INLINE_SPECIFIER static __inline
#endif
#define PJ_THREAD_FUNC
#define PJ_NORETURN
#define PJ_ATTR_NORETURN __attribute__ ((noreturn))
#define PJ_ATTR_MAY_ALIAS __attribute__ ((__may_alias__))
#define PJ_HAS_INT64 1
typedef long long pj_int64_t;
typedef unsigned long long pj_uint64_t;
#define PJ_INT64_FMT "L"
#define PJ_UNREACHED(x)
#endif /* __PJ_COMPAT_CC_ARMCC_H__ */

64
GSMGateway/app/src/main/cpp/pj/compat/cc_clang.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright (C) 2023 Teluu Inc. (http://www.teluu.com)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_CC_CLANG_H__
#define __PJ_COMPAT_CC_CLANG_H__
/**
* @file cc_clang.h
* @brief Describes CLANG compiler specifics.
*/
#ifndef __clang__
# error "This file is only for clang!"
#endif
#define PJ_CC_NAME "clang"
#define PJ_CC_VER_1 __clang_major__
#define PJ_CC_VER_2 __clang_minor__
#define PJ_CC_VER_3 __clang_patchlevel__
#define PJ_THREAD_FUNC
#define PJ_NORETURN
#define PJ_HAS_INT64 1
#ifdef __STRICT_ANSI__
#include <inttypes.h>
typedef int64_t pj_int64_t;
typedef uint64_t pj_uint64_t;
#define PJ_INLINE_SPECIFIER static __inline
#define PJ_ATTR_NORETURN
#define PJ_ATTR_MAY_ALIAS
#else
typedef long long pj_int64_t;
typedef unsigned long long pj_uint64_t;
#define PJ_INLINE_SPECIFIER static inline
#define PJ_ATTR_NORETURN __attribute__ ((noreturn))
#define PJ_ATTR_MAY_ALIAS __attribute__((__may_alias__))
#endif
#define PJ_INT64(val) val##LL
#define PJ_UINT64(val) val##ULL
#define PJ_INT64_FMT "L"
#define PJ_UNREACHED(x)
#define PJ_ALIGN_DATA(declaration, alignment) declaration __attribute__((aligned(alignment)))
#endif /* __PJ_COMPAT_CC_CLANG_H__ */

55
GSMGateway/app/src/main/cpp/pj/compat/cc_codew.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_CC_CODEW_H__
#define __PJ_COMPAT_CC_CODEW_H__
/**
* @file cc_codew.h
* @brief Describes MetroWerks Code Warrior compiler specifics.
*/
#ifndef __MWERKS__
# error "This file is only for Code Warrior!"
#endif
#define PJ_CC_NAME "codewarrior"
#define PJ_CC_VER_1 ((__MWERKS__ & 0xF000) >> 12)
#define PJ_CC_VER_2 ((__MWERKS__ & 0x0F00) >> 8)
#define PJ_CC_VER_3 ((__MWERKS__ & 0xFF))
#define PJ_INLINE_SPECIFIER static inline
#define PJ_THREAD_FUNC
#define PJ_NORETURN
#define PJ_ATTR_NORETURN
#define PJ_ATTR_MAY_ALIAS
#define PJ_HAS_INT64 1
typedef long long pj_int64_t;
typedef unsigned long long pj_uint64_t;
#define PJ_INT64(val) val##LL
#define PJ_UINT64(val) val##LLU
#define PJ_INT64_FMT "L"
#define PJ_UNREACHED(x)
#endif /* __PJ_COMPAT_CC_CODEW_H__ */

79
GSMGateway/app/src/main/cpp/pj/compat/cc_gcc.h Normal file
View File

@@ -0,0 +1,79 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_CC_GCC_H__
#define __PJ_COMPAT_CC_GCC_H__
/**
* @file cc_gcc.h
* @brief Describes GCC compiler specifics.
*/
#ifndef __GNUC__
# error "This file is only for gcc!"
#endif
#define PJ_CC_NAME "gcc"
#define PJ_CC_VER_1 __GNUC__
#define PJ_CC_VER_2 __GNUC_MINOR__
/* __GNUC_PATCHLEVEL__ doesn't exist in gcc-2.9x.x */
#ifdef __GNUC_PATCHLEVEL__
# define PJ_CC_VER_3 __GNUC_PATCHLEVEL__
#else
# define PJ_CC_VER_3 0
#endif
#define PJ_THREAD_FUNC
#define PJ_NORETURN
#define PJ_HAS_INT64 1
#ifdef __STRICT_ANSI__
#include <inttypes.h>
typedef int64_t pj_int64_t;
typedef uint64_t pj_uint64_t;
#define PJ_INLINE_SPECIFIER static __inline
#define PJ_ATTR_NORETURN
#define PJ_ATTR_MAY_ALIAS
#else
typedef long long pj_int64_t;
typedef unsigned long long pj_uint64_t;
#define PJ_INLINE_SPECIFIER static inline
#define PJ_ATTR_NORETURN __attribute__ ((noreturn))
#define PJ_ATTR_MAY_ALIAS __attribute__((__may_alias__))
#endif
#define PJ_INT64(val) val##LL
#define PJ_UINT64(val) val##ULL
#define PJ_INT64_FMT "L"
#ifdef __GLIBC__
# define PJ_HAS_BZERO 1
#endif
#define PJ_UNREACHED(x)
#define PJ_ALIGN_DATA(declaration, alignment) declaration __attribute__((aligned (alignment)))
#endif /* __PJ_COMPAT_CC_GCC_H__ */

54
GSMGateway/app/src/main/cpp/pj/compat/cc_gcce.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_CC_GCCE_H__
#define __PJ_COMPAT_CC_GCCE_H__
/**
* @file cc_gcce.h
* @brief Describes GCCE compiler specifics.
*/
#ifndef __GCCE__
# error "This file is only for gcce!"
#endif
#define PJ_CC_NAME "gcce"
#define PJ_CC_VER_1 __GCCE__
#define PJ_CC_VER_2 __GCCE_MINOR__
#define PJ_CC_VER_3 __GCCE_PATCHLEVEL__
#define PJ_INLINE_SPECIFIER static inline
#define PJ_THREAD_FUNC
#define PJ_NORETURN
#define PJ_ATTR_NORETURN __attribute__ ((noreturn))
#define PJ_ATTR_MAY_ALIAS __attribute__ ((__may_alias__))
#define PJ_HAS_INT64 1
typedef long long pj_int64_t;
typedef unsigned long long pj_uint64_t;
#define PJ_INT64(val) val##LL
#define PJ_UINT64(val) val##LLU
#define PJ_INT64_FMT "L"
#endif /* __PJ_COMPAT_CC_GCCE_H__ */

87
GSMGateway/app/src/main/cpp/pj/compat/cc_msvc.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_CC_MSVC_H__
#define __PJ_COMPAT_CC_MSVC_H__
/**
* @file cc_msvc.h
* @brief Describes Microsoft Visual C compiler specifics.
*/
#ifndef _MSC_VER
# error "This header file is only for Visual C compiler!"
#endif
#define PJ_CC_NAME "msvc"
#define PJ_CC_VER_1 (_MSC_VER/100)
#define PJ_CC_VER_2 (_MSC_VER%100)
#define PJ_CC_VER_3 0
/* Disable CRT deprecation warnings. */
#if PJ_CC_VER_1 >= 8 && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif
#if PJ_CC_VER_1 >= 8 && !defined(_CRT_SECURE_NO_WARNINGS)
# define _CRT_SECURE_NO_WARNINGS
/* The above doesn't seem to work, at least on VS2005, so lets use
* this construct as well.
*/
# pragma warning(disable: 4996)
#endif
#pragma warning(disable: 4127) // conditional expression is constant
#pragma warning(disable: 4611) // not wise to mix setjmp with C++
#pragma warning(disable: 4514) // unref. inline function has been removed
#ifdef NDEBUG
# pragma warning(disable: 4702) // unreachable code
# pragma warning(disable: 4710) // function is not inlined.
# pragma warning(disable: 4711) // function selected for auto inline expansion
#endif
#ifdef __cplusplus
# define PJ_INLINE_SPECIFIER inline
#else
# define PJ_INLINE_SPECIFIER static __inline
#endif
#define PJ_EXPORT_DECL_SPECIFIER __declspec(dllexport)
#define PJ_EXPORT_DEF_SPECIFIER __declspec(dllexport)
#define PJ_IMPORT_DECL_SPECIFIER __declspec(dllimport)
#define PJ_THREAD_FUNC
#define PJ_NORETURN __declspec(noreturn)
#define PJ_ATTR_NORETURN
#define PJ_ATTR_MAY_ALIAS
#define PJ_HAS_INT64 1
typedef __int64 pj_int64_t;
typedef unsigned __int64 pj_uint64_t;
#define PJ_INT64(val) val##i64
#define PJ_UINT64(val) val##ui64
#define PJ_INT64_FMT "I64"
#define PJ_UNREACHED(x)
#define PJ_ALIGN_DATA(declaration, alignment) __declspec(align(alignment)) declaration
#endif /* __PJ_COMPAT_CC_MSVC_H__ */

55
GSMGateway/app/src/main/cpp/pj/compat/cc_mwcc.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_CC_MWCC_H__
#define __PJ_COMPAT_CC_MWCC_H__
/**
* @file cc_mwcc.h
* @brief Describes MWCC compiler specifics.
*/
#ifndef __CW32__
# error "This file is only for mwcc!"
#endif
#define PJ_CC_NAME "mwcc32sym"
#define PJ_CC_VER_1 1
#define PJ_CC_VER_2 0
#define PJ_CC_VER_3 0
#define PJ_INLINE_SPECIFIER static inline
#define PJ_THREAD_FUNC
#define PJ_NORETURN
#define PJ_ATTR_NORETURN __attribute__ ((noreturn))
#define PJ_ATTR_MAY_ALIAS
#define PJ_HAS_INT64 1
typedef long long pj_int64_t;
typedef unsigned long long pj_uint64_t;
#define PJ_INT64(val) val##LL
#define PJ_UINT64(val) val##LLU
#define PJ_INT64_FMT "L"
#define PJ_UNREACHED(x)
#endif /* __PJ_COMPAT_CC_MWCC_H__ */

44
GSMGateway/app/src/main/cpp/pj/compat/ctype.h Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_CTYPE_H__
#define __PJ_COMPAT_CTYPE_H__
/**
* @file ctype.h
* @brief Provides ctype function family.
*/
#if defined(PJ_HAS_CTYPE_H) && PJ_HAS_CTYPE_H != 0
# include <ctype.h>
#else
# define isalnum(c) (isalpha(c) || isdigit(c))
# define isalpha(c) (islower(c) || isupper(c))
# define isascii(c) (((unsigned char)(c))<=0x7f)
# define isdigit(c) ((c)>='0' && (c)<='9')
# define isspace(c) ((c)==' ' || (c)=='\t' ||\
(c)=='\n' || (c)=='\r' || (c)=='\v')
# define islower(c) ((c)>='a' && (c)<='z')
# define isupper(c) ((c)>='A' && (c)<='Z')
# define isxdigit(c) (isdigit(c) || (tolower(c)>='a'&&tolower(c)<='f'))
# define tolower(c) (((c) >= 'A' && (c) <= 'Z') ? (c)+('a'-'A') : (c))
# define toupper(c) (((c) >= 'a' && (c) <= 'z') ? (c)-('a'-'A') : (c))
#endif
#endif /* __PJ_COMPAT_CTYPE_H__ */

44
GSMGateway/app/src/main/cpp/pj/compat/errno.h Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_ERRNO_H__
#define __PJ_COMPAT_ERRNO_H__
#if defined(PJ_WIN32) && PJ_WIN32 != 0 || \
defined(PJ_WIN32_WINCE) && PJ_WIN32_WINCE != 0 || \
defined(PJ_WIN64) && PJ_WIN64 != 0
typedef unsigned long pj_os_err_type;
# define pj_get_native_os_error() GetLastError()
# define pj_get_native_netos_error() WSAGetLastError()
#elif defined(PJ_HAS_ERRNO_VAR) && PJ_HAS_ERRNO_VAR!= 0
typedef int pj_os_err_type;
# define pj_get_native_os_error() (errno)
# define pj_get_native_netos_error() (errno)
#else
# error "Please define how to get errno for this platform here!"
#endif
#endif /* __PJ_COMPAT_ERRNO_H__ */

87
GSMGateway/app/src/main/cpp/pj/compat/high_precision.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_HIGH_PRECISION_H__
#define __PJ_COMPAT_HIGH_PRECISION_H__
#if defined(PJ_HAS_FLOATING_POINT) && PJ_HAS_FLOATING_POINT != 0
/*
* The first choice for high precision math is to use double.
*/
# include <math.h>
typedef double pj_highprec_t;
# define PJ_HIGHPREC_VALUE_IS_ZERO(a) (a==0)
# define pj_highprec_mod(a,b) (a=fmod(a,b))
#elif defined(PJ_HAS_INT64) && PJ_HAS_INT64 != 0
/*
* Next choice is to use 64-bit arithmatics.
*/
typedef pj_int64_t pj_highprec_t;
#else
# warning "High precision math is not available"
/*
* Last, fallback to 32-bit arithmetics.
*/
typedef pj_int32_t pj_highprec_t;
#endif
/**
* @def pj_highprec_mul
* pj_highprec_mul(a1, a2) - High Precision Multiplication
* Multiply a1 and a2, and store the result in a1.
*/
#ifndef pj_highprec_mul
# define pj_highprec_mul(a1,a2) (a1 = a1 * a2)
#endif
/**
* @def pj_highprec_div
* pj_highprec_div(a1, a2) - High Precision Division
* Divide a2 from a1, and store the result in a1.
*/
#ifndef pj_highprec_div
# define pj_highprec_div(a1,a2) (a1 = a1 / a2)
#endif
/**
* @def pj_highprec_mod
* pj_highprec_mod(a1, a2) - High Precision Modulus
* Get the modulus a2 from a1, and store the result in a1.
*/
#ifndef pj_highprec_mod
# define pj_highprec_mod(a1,a2) (a1 = a1 % a2)
#endif
/**
* @def PJ_HIGHPREC_VALUE_IS_ZERO(a)
* Test if the specified high precision value is zero.
*/
#ifndef PJ_HIGHPREC_VALUE_IS_ZERO
# define PJ_HIGHPREC_VALUE_IS_ZERO(a) (a==0)
#endif
#endif /* __PJ_COMPAT_HIGH_PRECISION_H__ */

66
GSMGateway/app/src/main/cpp/pj/compat/limits.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* Copyright (C) 2017 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2017 George Joseph <gjoseph@digium.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_LIMITS_H__
#define __PJ_COMPAT_LIMITS_H__
/**
* @file limits.h
* @brief Provides integer limits normally found in limits.h.
*/
#include <pj/config.h>
#if defined(PJ_HAS_LIMITS_H) && PJ_HAS_LIMITS_H != 0
# include <limits.h>
#else
# ifdef _MSC_VER
# pragma message("limits.h is not found or not supported. LONG_MIN and "\
"LONG_MAX will be defined by the library in "\
"pj/compats/limits.h and overridable in config_site.h")
# else
# warning "limits.h is not found or not supported. LONG_MIN and LONG_MAX " \
"will be defined by the library in pj/compats/limits.h and "\
"overridable in config_site.h"
# endif
/* Minimum and maximum values a `signed long int' can hold. */
# ifndef LONG_MAX
# if __WORDSIZE == 64
# define LONG_MAX 9223372036854775807L
# else
# define LONG_MAX 2147483647L
# endif
# endif
# ifndef LONG_MIN
# define LONG_MIN (-LONG_MAX - 1L)
# endif
/* Maximum value an `unsigned long int' can hold. (Minimum is 0.) */
# ifndef ULONG_MAX
# if __WORDSIZE == 64
# define ULONG_MAX 18446744073709551615UL
# else
# define ULONG_MAX 4294967295UL
# endif
# endif
#endif
#endif /* __PJ_COMPAT_LIMITS_H__ */

35
GSMGateway/app/src/main/cpp/pj/compat/m_alpha.h Normal file
View File

@@ -0,0 +1,35 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_ALPHA_H__
#define __PJ_COMPAT_M_ALPHA_H__
/**
* @file m_alpha.h
* @brief Describes Alpha processor family specifics.
*/
#define PJ_M_NAME "alpha"
#define PJ_HAS_PENTIUM 0
#define PJ_IS_LITTLE_ENDIAN 1
#define PJ_IS_BIG_ENDIAN 0
#endif /* __PJ_COMPAT_M_ALPHA_H__ */

38
GSMGateway/app/src/main/cpp/pj/compat/m_armv4.h Normal file
View File

@@ -0,0 +1,38 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_ARMV4_H__
#define __PJ_COMPAT_M_ARMV4_H__
/**
* @file m_armv4.h
* @brief Describes ARM family processor specifics.
*/
/*
* This file covers PJ_M_ARMV4 etc.
*/
#define PJ_M_NAME "armv4"
#define PJ_HAS_PENTIUM 0
#define PJ_IS_LITTLE_ENDIAN 1
#define PJ_IS_BIG_ENDIAN 0
#endif /* __PJ_COMPAT_M_ARMV4_H__ */

60
GSMGateway/app/src/main/cpp/pj/compat/m_auto.h Normal file
View File

@@ -0,0 +1,60 @@
/* pjlib/include/pj/compat/m_auto.h. Generated from m_auto.h.in by configure. */
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_AUTO_H__
#define __PJ_COMPAT_M_AUTO_H__
/**
* @file m_auto.h
* @brief Automatically generated process definition file.
*/
/* Machine name, filled in by autoconf script */
#define PJ_M_NAME "aarch64"
/* Endianness. It's reported on pjsip list on 09/02/13 that autoconf
* endianness detection failed for universal build, so special case
* for it here. Thanks Ruud Klaver for the fix.
*/
#ifdef PJ_DARWINOS
# ifdef __BIG_ENDIAN__
# define WORDS_BIGENDIAN 1
# endif
#else
/* Endianness, as detected by autoconf */
/* # undef WORDS_BIGENDIAN */
#endif
#ifdef WORDS_BIGENDIAN
# define PJ_IS_LITTLE_ENDIAN 0
# define PJ_IS_BIG_ENDIAN 1
#else
# define PJ_IS_LITTLE_ENDIAN 1
# define PJ_IS_BIG_ENDIAN 0
#endif
/* Specify if floating point is present/desired */
#define PJ_HAS_FLOATING_POINT 1
/* Deprecated */
#define PJ_HAS_PENTIUM 0
#endif /* __PJ_COMPAT_M_AUTO_H__ */

59
GSMGateway/app/src/main/cpp/pj/compat/m_auto.h.in Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_AUTO_H__
#define __PJ_COMPAT_M_AUTO_H__
/**
* @file m_auto.h
* @brief Automatically generated process definition file.
*/
/* Machine name, filled in by autoconf script */
#undef PJ_M_NAME
/* Endianness. It's reported on pjsip list on 09/02/13 that autoconf
* endianness detection failed for universal build, so special case
* for it here. Thanks Ruud Klaver for the fix.
*/
#ifdef PJ_DARWINOS
# ifdef __BIG_ENDIAN__
# define WORDS_BIGENDIAN 1
# endif
#else
/* Endianness, as detected by autoconf */
# undef WORDS_BIGENDIAN
#endif
#ifdef WORDS_BIGENDIAN
# define PJ_IS_LITTLE_ENDIAN 0
# define PJ_IS_BIG_ENDIAN 1
#else
# define PJ_IS_LITTLE_ENDIAN 1
# define PJ_IS_BIG_ENDIAN 0
#endif
/* Specify if floating point is present/desired */
#undef PJ_HAS_FLOATING_POINT
/* Deprecated */
#define PJ_HAS_PENTIUM 0
#endif /* __PJ_COMPAT_M_AUTO_H__ */

34
GSMGateway/app/src/main/cpp/pj/compat/m_i386.h Normal file
View File

@@ -0,0 +1,34 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_i386_H__
#define __PJ_COMPAT_M_i386_H__
/**
* @file m_i386.h
* @brief Describes Intel i386 family processor specifics.
*/
#define PJ_M_NAME "i386"
#define PJ_HAS_PENTIUM 1
#define PJ_IS_LITTLE_ENDIAN 1
#define PJ_IS_BIG_ENDIAN 0
#endif /* __PJ_COMPAT_M_i386_H__ */

34
GSMGateway/app/src/main/cpp/pj/compat/m_m68k.h Normal file
View File

@@ -0,0 +1,34 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_M68K_H__
#define __PJ_COMPAT_M_M68K_H__
/**
* @file m_m68k.h
* @brief Describes Motorola m68k family processor specifics.
*/
#define PJ_M_NAME "m68k"
#define PJ_HAS_PENTIUM 0
#define PJ_IS_LITTLE_ENDIAN 1
#define PJ_IS_BIG_ENDIAN 0
#endif /* __PJ_COMPAT_M_M68K_H__ */

35
GSMGateway/app/src/main/cpp/pj/compat/m_powerpc.h Normal file
View File

@@ -0,0 +1,35 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_POWERPC_H__
#define __PJ_COMPAT_M_POWERPC_H__
/**
* @file m_ppc.h
* @brief Describes PowerPC family processor specifics.
*/
#define PJ_M_NAME "powerpc"
#define PJ_HAS_PENTIUM 0
#define PJ_IS_LITTLE_ENDIAN 0
#define PJ_IS_BIG_ENDIAN 1
#endif /* __PJ_COMPAT_M_POWERPC_H__ */

34
GSMGateway/app/src/main/cpp/pj/compat/m_sparc.h Normal file
View File

@@ -0,0 +1,34 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_SPARC_H__
#define __PJ_COMPAT_M_SPARC_H__
/**
* @file m_sparc.h
* @brief Describes SPARC family processor specifics.
*/
#define PJ_M_NAME "sparc"
#define PJ_HAS_PENTIUM 0
#define PJ_IS_LITTLE_ENDIAN 0
#define PJ_IS_BIG_ENDIAN 1
#endif /* __PJ_COMPAT_M_SPARC_H__ */

35
GSMGateway/app/src/main/cpp/pj/compat/m_x86_64.h Normal file
View File

@@ -0,0 +1,35 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_M_x86_64_H__
#define __PJ_COMPAT_M_x86_64_H__
/**
* @file m_i386.h
* @brief Describes 64bit x86 Intel/AMD family processor specifics.
*/
#define PJ_M_NAME "x86_64"
#define PJ_HAS_PENTIUM 1
#define PJ_IS_LITTLE_ENDIAN 1
#define PJ_IS_BIG_ENDIAN 0
#endif /* __PJ_COMPAT_M_x86_64_H__ */

33
GSMGateway/app/src/main/cpp/pj/compat/malloc.h Normal file
View File

@@ -0,0 +1,33 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_MALLOC_H__
#define __PJ_COMPAT_MALLOC_H__
/**
* @file malloc.h
* @brief Provides malloc() and free() functions.
*/
#if defined(PJ_HAS_MALLOC_H) && PJ_HAS_MALLOC_H != 0
# include <malloc.h>
#elif defined(PJ_HAS_STDLIB_H) && PJ_HAS_STDLIB_H != 0
# include <stdlib.h>
#endif
#endif /* __PJ_COMPAT_MALLOC_H__ */

245
GSMGateway/app/src/main/cpp/pj/compat/os_auto.h Normal file
View File

@@ -0,0 +1,245 @@
/* pjlib/include/pj/compat/os_auto.h. Generated from os_auto.h.in by configure. */
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_AUTO_H__
#define __PJ_COMPAT_OS_AUTO_H__
/**
* @file os_auto.h
* @brief Describes operating system specifics (automatically detected by
* autoconf)
*/
/* Canonical OS name */
#define PJ_OS_NAME "aarch64-unknown-linux-android"
/* Legacy macros */
/* #undef PJ_WIN64 */
/* #undef PJ_WIN32 */
/* #undef PJ_WIN32_WINNT */
/* #undef WIN32_LEAN_AND_MEAN */
/* #undef PJ_DARWINOS */
/* #undef PJ_LINUX */
/* #undef PJ_BSD */
/* #undef PJ_RTEMS */
/* #undef PJ_SUNOS */
#define PJ_ANDROID 1
#if defined(PJ_WIN32_WINNT) && !defined(_WIN32_WINNT)
# define _WIN32_WINNT PJ_WIN32_WINNT
#endif
/* Headers availability */
#define PJ_HAS_ARPA_INET_H 1
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 1
#define PJ_HAS_FCNTL_H 1
#define PJ_HAS_LIMITS_H 1
#define PJ_HAS_LINUX_SOCKET_H 1
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 1
#define PJ_HAS_NETINET_IN_SYSTM_H 1
#define PJ_HAS_NETINET_IN_H 1
#define PJ_HAS_NETINET_IP_H 1
#define PJ_HAS_NETINET_TCP_H 1
#define PJ_HAS_NET_IF_H 1
#define PJ_HAS_IFADDRS_H 1
#define PJ_HAS_INTTYPES_H 1
#define PJ_HAS_SEMAPHORE_H 1
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDINT_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 1
#define PJ_HAS_SYS_SELECT_H 1
#define PJ_HAS_SYS_SOCKET_H 1
#define PJ_HAS_SYS_TIME_H 1
/* #undef PJ_HAS_SYS_TIMEB_H */
#define PJ_HAS_SYS_TYPES_H 1
/* #undef PJ_HAS_SYS_FILIO_H */
/* #undef PJ_HAS_SYS_SOCKIO_H */
#define PJ_HAS_SYS_UTSNAME_H 1
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 1
#define PJ_HAS_EXECINFO_H 1
/* #undef PJ_HAS_MSWSOCK_H */
/* #undef PJ_HAS_WINSOCK_H */
/* #undef PJ_HAS_WINSOCK2_H */
/* #undef PJ_HAS_WS2TCPIP_H */
#define PJ_SOCK_HAS_IPV6_V6ONLY 1
#define PJ_SOCK_HAS_INET_ATON 1
#define PJ_SOCK_HAS_INET_PTON 1
#define PJ_SOCK_HAS_INET_NTOP 1
#define PJ_SOCK_HAS_GETADDRINFO 1
#define PJ_SOCK_HAS_SOCKETPAIR 1
/* On these OSes, semaphore feature depends on semaphore.h */
#if defined(PJ_HAS_SEMAPHORE_H) && PJ_HAS_SEMAPHORE_H!=0
# define PJ_HAS_SEMAPHORE 1
#elif defined(PJ_WIN32) && PJ_WIN32!=0
# define PJ_HAS_SEMAPHORE 1
#else
# define PJ_HAS_SEMAPHORE 0
#endif
/* Do we have pthread_mutexattr_settype()? */
/* #undef PJ_HAS_PTHREAD_MUTEXATTR_SETTYPE */
/* Does pthread_mutexattr_t has "recursive" member? */
/* #undef PJ_PTHREAD_MUTEXATTR_T_HAS_RECURSIVE */
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
/* #undef PJ_SOCKADDR_HAS_LEN */
/* Does the OS have socklen_t? */
#define PJ_HAS_SOCKLEN_T 1
#if !defined(socklen_t) && (!defined(PJ_HAS_SOCKLEN_T) || PJ_HAS_SOCKLEN_T==0)
# define PJ_HAS_SOCKLEN_T 1
typedef int socklen_t;
#endif
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* Was Linux epoll support enabled */
/* #undef PJ_HAS_LINUX_EPOLL */
/* Is errno a good way to retrieve OS errors?
*/
#define PJ_HAS_ERRNO_VAR 1
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 1
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() can not return immediate daata.
*/
#define PJ_BLOCKING_ERROR_VAL EAGAIN
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL EINPROGRESS
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
/* Do we need high resolution timer? */
#define PJ_HAS_HIGH_RES_TIMER 1
/* Is malloc() available? */
#define PJ_HAS_MALLOC 1
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
#endif
/* Is localtime_r() available? */
#define PJ_HAS_LOCALTIME_R 1
/* Unicode? */
#define PJ_NATIVE_STRING_IS_UNICODE 0
/* Pool alignment in bytes */
#define PJ_POOL_ALIGNMENT 8
/* The type of atomic variable value: */
#define PJ_ATOMIC_VALUE_TYPE long
#if defined(PJ_DARWINOS) && PJ_DARWINOS!=0
/* Disable local host resolution in pj_gethostip() (see ticket #1342) */
# define PJ_GETHOSTIP_DISABLE_LOCAL_RESOLUTION 1
/* Use pj_getaddrinfo() (instead of pj_inet_pton()) in
* pj_sockaddr_set_str_addr()
*/
# define PJ_SOCKADDR_USE_GETADDRINFO 1
# include "TargetConditionals.h"
# if TARGET_OS_IPHONE
# include "Availability.h"
/* Use CFHost API for pj_getaddrinfo() (see ticket #1246) */
# ifndef PJ_GETADDRINFO_USE_CFHOST
# define PJ_GETADDRINFO_USE_CFHOST 0
# endif
# ifdef __IPHONE_4_0
/* Is multitasking support available? (see ticket #1107) */
# define PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT 1
/* Activesock TCP background mode support (VoIP socket).
* Disabled by default, VoIP socket deprecated since iOS 9 and
* on iOS16 using VoIP socket causes app getting killed.
*/
# define PJ_ACTIVESOCK_TCP_IPHONE_OS_BG 0
# endif
# endif
#endif
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 0
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
/* SSL socket availability. */
#ifndef PJ_HAS_SSL_SOCK
/* #undef PJ_HAS_SSL_SOCK */
#endif
#ifndef PJ_SSL_SOCK_IMP
/* #undef PJ_SSL_SOCK_IMP */
#endif
/* Has pthread_np.h ? */
/* #undef PJ_HAS_PTHREAD_NP_H */
/* Has pthread_setname_np() ? */
#define PJ_HAS_PTHREAD_SETNAME_NP 1
/* Has pthread_set_name_np() ? */
/* #undef PJ_HAS_PTHREAD_SET_NAME_NP */
#endif /* __PJ_COMPAT_OS_AUTO_H__ */

244
GSMGateway/app/src/main/cpp/pj/compat/os_auto.h.in Normal file
View File

@@ -0,0 +1,244 @@
/*
* Copyright (C) 2008-2009 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_AUTO_H__
#define __PJ_COMPAT_OS_AUTO_H__
/**
* @file os_auto.h
* @brief Describes operating system specifics (automatically detected by
* autoconf)
*/
/* Canonical OS name */
#undef PJ_OS_NAME
/* Legacy macros */
#undef PJ_WIN64
#undef PJ_WIN32
#undef PJ_WIN32_WINNT
#undef WIN32_LEAN_AND_MEAN
#undef PJ_DARWINOS
#undef PJ_LINUX
#undef PJ_BSD
#undef PJ_RTEMS
#undef PJ_SUNOS
#undef PJ_ANDROID
#if defined(PJ_WIN32_WINNT) && !defined(_WIN32_WINNT)
# define _WIN32_WINNT PJ_WIN32_WINNT
#endif
/* Headers availability */
#undef PJ_HAS_ARPA_INET_H
#undef PJ_HAS_ASSERT_H
#undef PJ_HAS_CTYPE_H
#undef PJ_HAS_ERRNO_H
#undef PJ_HAS_FCNTL_H
#undef PJ_HAS_LIMITS_H
#undef PJ_HAS_LINUX_SOCKET_H
#undef PJ_HAS_MALLOC_H
#undef PJ_HAS_NETDB_H
#undef PJ_HAS_NETINET_IN_SYSTM_H
#undef PJ_HAS_NETINET_IN_H
#undef PJ_HAS_NETINET_IP_H
#undef PJ_HAS_NETINET_TCP_H
#undef PJ_HAS_NET_IF_H
#undef PJ_HAS_IFADDRS_H
#undef PJ_HAS_INTTYPES_H
#undef PJ_HAS_SEMAPHORE_H
#undef PJ_HAS_SETJMP_H
#undef PJ_HAS_STDARG_H
#undef PJ_HAS_STDDEF_H
#undef PJ_HAS_STDIO_H
#undef PJ_HAS_STDINT_H
#undef PJ_HAS_STDLIB_H
#undef PJ_HAS_STRING_H
#undef PJ_HAS_SYS_IOCTL_H
#undef PJ_HAS_SYS_SELECT_H
#undef PJ_HAS_SYS_SOCKET_H
#undef PJ_HAS_SYS_TIME_H
#undef PJ_HAS_SYS_TIMEB_H
#undef PJ_HAS_SYS_TYPES_H
#undef PJ_HAS_SYS_FILIO_H
#undef PJ_HAS_SYS_SOCKIO_H
#undef PJ_HAS_SYS_UTSNAME_H
#undef PJ_HAS_TIME_H
#undef PJ_HAS_UNISTD_H
#undef PJ_HAS_EXECINFO_H
#undef PJ_HAS_MSWSOCK_H
#undef PJ_HAS_WINSOCK_H
#undef PJ_HAS_WINSOCK2_H
#undef PJ_HAS_WS2TCPIP_H
#undef PJ_SOCK_HAS_IPV6_V6ONLY
#undef PJ_SOCK_HAS_INET_ATON
#undef PJ_SOCK_HAS_INET_PTON
#undef PJ_SOCK_HAS_INET_NTOP
#undef PJ_SOCK_HAS_GETADDRINFO
#undef PJ_SOCK_HAS_SOCKETPAIR
/* On these OSes, semaphore feature depends on semaphore.h */
#if defined(PJ_HAS_SEMAPHORE_H) && PJ_HAS_SEMAPHORE_H!=0
# define PJ_HAS_SEMAPHORE 1
#elif defined(PJ_WIN32) && PJ_WIN32!=0
# define PJ_HAS_SEMAPHORE 1
#else
# define PJ_HAS_SEMAPHORE 0
#endif
/* Do we have pthread_mutexattr_settype()? */
#undef PJ_HAS_PTHREAD_MUTEXATTR_SETTYPE
/* Does pthread_mutexattr_t has "recursive" member? */
#undef PJ_PTHREAD_MUTEXATTR_T_HAS_RECURSIVE
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#undef PJ_SOCKADDR_HAS_LEN
/* Does the OS have socklen_t? */
#undef PJ_HAS_SOCKLEN_T
#if !defined(socklen_t) && (!defined(PJ_HAS_SOCKLEN_T) || PJ_HAS_SOCKLEN_T==0)
# define PJ_HAS_SOCKLEN_T 1
typedef int socklen_t;
#endif
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#undef PJ_SELECT_NEEDS_NFDS
/* Was Linux epoll support enabled */
#undef PJ_HAS_LINUX_EPOLL
/* Is errno a good way to retrieve OS errors?
*/
#undef PJ_HAS_ERRNO_VAR
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#undef PJ_HAS_SO_ERROR
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() can not return immediate daata.
*/
#undef PJ_BLOCKING_ERROR_VAL
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#undef PJ_BLOCKING_CONNECT_ERROR_VAL
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
/* Do we need high resolution timer? */
#undef PJ_HAS_HIGH_RES_TIMER
/* Is malloc() available? */
#undef PJ_HAS_MALLOC
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
#endif
/* Is localtime_r() available? */
#undef PJ_HAS_LOCALTIME_R
/* Unicode? */
#undef PJ_NATIVE_STRING_IS_UNICODE
/* Pool alignment in bytes */
#undef PJ_POOL_ALIGNMENT
/* The type of atomic variable value: */
#undef PJ_ATOMIC_VALUE_TYPE
#if defined(PJ_DARWINOS) && PJ_DARWINOS!=0
/* Disable local host resolution in pj_gethostip() (see ticket #1342) */
# define PJ_GETHOSTIP_DISABLE_LOCAL_RESOLUTION 1
/* Use pj_getaddrinfo() (instead of pj_inet_pton()) in
* pj_sockaddr_set_str_addr()
*/
# define PJ_SOCKADDR_USE_GETADDRINFO 1
# include "TargetConditionals.h"
# if TARGET_OS_IPHONE
# include "Availability.h"
/* Use CFHost API for pj_getaddrinfo() (see ticket #1246) */
# ifndef PJ_GETADDRINFO_USE_CFHOST
# define PJ_GETADDRINFO_USE_CFHOST 0
# endif
# ifdef __IPHONE_4_0
/* Is multitasking support available? (see ticket #1107) */
# define PJ_IPHONE_OS_HAS_MULTITASKING_SUPPORT 1
/* Activesock TCP background mode support (VoIP socket).
* Disabled by default, VoIP socket deprecated since iOS 9 and
* on iOS16 using VoIP socket causes app getting killed.
*/
# define PJ_ACTIVESOCK_TCP_IPHONE_OS_BG 0
# endif
# endif
#endif
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#undef PJ_EMULATE_RWMUTEX
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#undef PJ_THREAD_SET_STACK_SIZE
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#undef PJ_THREAD_ALLOCATE_STACK
/* SSL socket availability. */
#ifndef PJ_HAS_SSL_SOCK
#undef PJ_HAS_SSL_SOCK
#endif
#ifndef PJ_SSL_SOCK_IMP
#undef PJ_SSL_SOCK_IMP
#endif
/* Has pthread_np.h ? */
#undef PJ_HAS_PTHREAD_NP_H
/* Has pthread_setname_np() ? */
#undef PJ_HAS_PTHREAD_SETNAME_NP
/* Has pthread_set_name_np() ? */
#undef PJ_HAS_PTHREAD_SET_NAME_NP
#endif /* __PJ_COMPAT_OS_AUTO_H__ */

141
GSMGateway/app/src/main/cpp/pj/compat/os_darwinos.h Normal file
View File

@@ -0,0 +1,141 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_DARWINOS_H__
#define __PJ_COMPAT_OS_DARWINOS_H__
/**
* @file os_darwinos.h
* @brief Describes Darwin/MacOSX operating system specifics.
*/
#define PJ_OS_NAME "darwin"
#define PJ_HAS_ARPA_INET_H 1
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 1
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 0
#define PJ_HAS_NETDB_H 1
#define PJ_HAS_NETINET_IN_H 1
#define PJ_HAS_NETINET_TCP_H 1
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 1
#define PJ_HAS_SYS_SELECT_H 1
#define PJ_HAS_SYS_SOCKET_H 1
#define PJ_HAS_SYS_TIME_H 1
#define PJ_HAS_SYS_TIMEB_H 1
#define PJ_HAS_SYS_TYPES_H 1
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 1
#define PJ_HAS_MSWSOCK_H 0
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 0
#define PJ_HAS_LOCALTIME_R 1
/* Is errno a good way to retrieve OS errors?
*/
#define PJ_HAS_ERRNO_VAR 1
/* Has inet_aton() ?
*/
#define PJ_SOCK_HAS_INET_ATON 1
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 1
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() can not return immediate daata.
*/
#define PJ_BLOCKING_ERROR_VAL EWOULDBLOCK
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL EINPROGRESS
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_HAS_MALLOC 1
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
#endif
#define PJ_NATIVE_STRING_IS_UNICODE 0
#define PJ_ATOMIC_VALUE_TYPE long
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 1
/*
* gcc complains that it can not use precompiled header because
* the value of FD_SETSIZE that we declare in pj/config.h is
* different than the value in /usr/include/sys/types.h.
*
* This changes the default value for Darwin.
*/
#define PJ_IOQUEUE_MAX_HANDLES 1024
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 0
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
/* MacOS has had socklen since 10.4 */
#define PJ_HAS_SOCKLEN_T 1
#endif /* __PJ_COMPAT_OS_DARWINOS_H__ */

130
GSMGateway/app/src/main/cpp/pj/compat/os_linux.h Normal file
View File

@@ -0,0 +1,130 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_LINUX_H__
#define __PJ_COMPAT_OS_LINUX_H__
/**
* @file os_linux.h
* @brief Describes Linux operating system specifics.
*/
#define PJ_OS_NAME "linux"
#define PJ_HAS_ARPA_INET_H 1
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 1
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 1
#define PJ_HAS_NETINET_IN_H 1
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 1
#define PJ_HAS_SYS_SELECT_H 1
#define PJ_HAS_SYS_SOCKET_H 1
#define PJ_HAS_SYS_TIME_H 1
#define PJ_HAS_SYS_TIMEB_H 1
#define PJ_HAS_SYS_TYPES_H 1
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 1
#define PJ_HAS_SEMAPHORE_H 1
#define PJ_HAS_MSWSOCK_H 0
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 0
#define PJ_HAS_LOCALTIME_R 1
#define PJ_SOCK_HAS_INET_ATON 1
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 0
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* Is errno a good way to retrieve OS errors?
*/
#define PJ_HAS_ERRNO_VAR 1
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 1
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() can not return immediate daata.
*/
#define PJ_BLOCKING_ERROR_VAL EAGAIN
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL EINPROGRESS
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_HAS_MALLOC 1
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
#endif
#define PJ_NATIVE_STRING_IS_UNICODE 0
#define PJ_ATOMIC_VALUE_TYPE long
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 0
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
/* Linux has socklen_t */
#define PJ_HAS_SOCKLEN_T 1
#endif /* __PJ_COMPAT_OS_LINUX_H__ */

118
GSMGateway/app/src/main/cpp/pj/compat/os_palmos.h Normal file
View File

@@ -0,0 +1,118 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_PALMOS_H__
#define __PJ_COMPAT_OS_PALMOS_H__
/**
* @file os_palmos.h
* @brief Describes PalmOS operating system specifics.
*/
#define PJ_OS_NAME "palmos"
#define PJ_HAS_ARPA_INET_H 0
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 0
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 0
#define PJ_HAS_NETINET_IN_H 0
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 0
#define PJ_HAS_SYS_SELECT_H 0
#define PJ_HAS_SYS_SOCKET_H 0
#define PJ_HAS_SYS_TIMEB_H 0
#define PJ_HAS_SYS_TYPES_H 1
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 0
#define PJ_HAS_MSWSOCK_H 0
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 0
#define PJ_SOCK_HAS_INET_ATON 0
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 0
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* Is errno a good way to retrieve OS errors?
*/
#define PJ_HAS_ERRNO_VAR 0
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 0
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() can not return immediate daata.
*/
#define PJ_BLOCKING_ERROR_VAL xxx
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL xxx
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
#define PJ_NATIVE_STRING_IS_UNICODE 0
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 1
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
#endif /* __PJ_COMPAT_OS_PALMOS_H__ */

138
GSMGateway/app/src/main/cpp/pj/compat/os_rtems.h Normal file
View File

@@ -0,0 +1,138 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*
* Thanks Zetron, Inc and Phil Torre <ptorre@zetron.com> for donating PJLIB
* port to RTEMS.
*/
#ifndef __PJ_COMPAT_OS_RTEMS_H__
#define __PJ_COMPAT_OS_RTEMS_H__
/**
* @file os_linux.h
* @brief Describes Linux operating system specifics.
*/
#define PJ_OS_NAME "rtems"
#define PJ_HAS_ARPA_INET_H 1
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 1
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 1
#define PJ_HAS_NETINET_IN_H 1
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 0
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 1
#define PJ_HAS_SYS_SELECT_H 1
#define PJ_HAS_SYS_SOCKET_H 1
#define PJ_HAS_SYS_TIME_H 1
#define PJ_HAS_SYS_TIMEB_H 1
#define PJ_HAS_SYS_TYPES_H 1
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 1
#define PJ_HAS_MSWSOCK_H 0
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 0
#define PJ_SOCK_HAS_INET_ATON 1
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 1
/* Is errno a good way to retrieve OS errors?
*/
#define PJ_HAS_ERRNO_VAR 1
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 1
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 1
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() can not return immediate daata.
*/
#define PJ_BLOCKING_ERROR_VAL EWOULDBLOCK
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL EINPROGRESS
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_HAS_MALLOC 1
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
#endif
#define PJ_NATIVE_STRING_IS_UNICODE 0
#define PJ_ATOMIC_VALUE_TYPE int
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 1
/* Missing socklen_t */
typedef int socklen_t;
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 1
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 1
/* RTEMS has socklen_t (does it? )*/
#define PJ_HAS_SOCKLEN_T 1
#endif /* __PJ_COMPAT_OS_RTEMS_H__ */

131
GSMGateway/app/src/main/cpp/pj/compat/os_sunos.h Normal file
View File

@@ -0,0 +1,131 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_SUNOS_H__
#define __PJ_COMPAT_OS_SUNOS_H__
/**
* @file os_sunos.h
* @brief Describes SunOS/Solaris operating system specifics.
*/
#define PJ_OS_NAME "sunos"
#define PJ_HAS_ARPA_INET_H 1
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 1
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 1
#define PJ_HAS_NETINET_IN_H 1
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 1
#define PJ_HAS_SYS_SELECT_H 1
#define PJ_HAS_SYS_SOCKET_H 1
#define PJ_HAS_SYS_TIME_H 0
#define PJ_HAS_SYS_TIMEB_H 1
#define PJ_HAS_SYS_TYPES_H 1
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 1
#define PJ_HAS_MSWSOCK_H 0
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 0
#define PJ_SOCK_HAS_INET_ATON 0
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 0
/* Is errno a good way to retrieve OS errors?
*/
#define PJ_HAS_ERRNO_VAR 1
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 0
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() can not return immediate daata.
*/
#define PJ_BLOCKING_ERROR_VAL EWOULDBLOCK
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL EINPROGRESS
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_HAS_MALLOC 1
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
#endif
#define PJ_NATIVE_STRING_IS_UNICODE 0
#define PJ_ATOMIC_VALUE_TYPE long
/* Get BSD related identifers in Sun's include files */
#define BSD_COMP
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 0
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
/* SunOS has socklen_t (does it? )*/
#define PJ_HAS_SOCKLEN_T 1
#endif /* __PJ_COMPAT_OS_SUNOS_H__ */

166
GSMGateway/app/src/main/cpp/pj/compat/os_symbian.h Normal file
View File

@@ -0,0 +1,166 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_SYMBIAN_H__
#define __PJ_COMPAT_OS_SYMBIAN_H__
/**
* @file os_symbian.h
* @brief Describes Symbian operating system specifics.
*/
#define PJ_OS_NAME "symbian"
#define PJ_HAS_ARPA_INET_H 1
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 1
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 0
#define PJ_HAS_NETDB_H 1
#define PJ_HAS_NETINET_IN_H 1
#define PJ_HAS_NETINET_TCP_H 0
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_NO_SNPRINTF 1
#define PJ_HAS_SYS_IOCTL_H 1
#define PJ_HAS_SYS_SELECT_H 0
#define PJ_HAS_SYS_SOCKET_H 1
#define PJ_HAS_SYS_TIME_H 1
#define PJ_HAS_SYS_TIMEB_H 0
#define PJ_HAS_SYS_TYPES_H 1
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 1
#define PJ_HAS_MSWSOCK_H 0
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 0
#define PJ_SOCK_HAS_INET_ATON 0
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 0
/* Is errno a good way to retrieve OS errors?
*/
#define PJ_HAS_ERRNO_VAR 1
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 1
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() can not return immediate daata.
*/
#define PJ_BLOCKING_ERROR_VAL EAGAIN
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL EINPROGRESS
/*
* We don't want to use threads in Symbian
*/
#define PJ_HAS_THREADS 0
/*
* Declare __FD_SETSIZE now before including <linux*>.
#define __FD_SETSIZE PJ_IOQUEUE_MAX_HANDLES
*/
#ifndef NULL
# define NULL 0
#endif
/* Endianness */
#ifndef PJ_IS_LITTLE_ENDIAN
# define PJ_IS_LITTLE_ENDIAN 1
# define PJ_IS_BIG_ENDIAN 0
#endif
/* Doesn't seem to allow more than this */
#define PJ_IOQUEUE_MAX_HANDLES 8
/*
* Override features.
*/
#define PJ_HAS_FLOATING_POINT 0
#define PJ_HAS_MALLOC 0
#define PJ_HAS_SEMAPHORE 1
#define PJ_HAS_EVENT_OBJ 0
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_OS_HAS_CHECK_STACK 0
#define PJ_TERM_HAS_COLOR 0
#define PJ_NATIVE_STRING_IS_UNICODE 0
#define PJ_NATIVE_ERR_POSITIVE 0
#define PJ_ATOMIC_VALUE_TYPE int
#define PJ_THREAD_DESC_SIZE 128
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 1
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
/* Missing socklen_t */
#define PJ_HAS_SOCKLEN_T 1
typedef unsigned int socklen_t;
#ifndef __GCCE__
#include <e32def.h>
#endif
#define PJ_EXPORT_DECL_SPECIFIER IMPORT_C
//#define PJ_EXPORT_DECL_SPECIFIER
#define PJ_EXPORT_DEF_SPECIFIER EXPORT_C
#define PJ_IMPORT_DECL_SPECIFIER IMPORT_C
#endif /* __PJ_COMPAT_OS_SYMBIAN_H__ */

148
GSMGateway/app/src/main/cpp/pj/compat/os_win32.h Normal file
View File

@@ -0,0 +1,148 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_WIN32_H__
#define __PJ_COMPAT_OS_WIN32_H__
/**
* @file os_win32.h
* @brief Describes Win32 operating system family specifics.
*/
#define PJ_OS_NAME "win32"
#define WIN32_LEAN_AND_MEAN
#define PJ_WIN32_WINNT 0x0501
#ifndef _WIN32_WINNT
# define _WIN32_WINNT PJ_WIN32_WINNT
#endif
#define PJ_HAS_ARPA_INET_H 0
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 0 /* Must be zero, otherwise errno_test() fails. */
#define PJ_HAS_INTTYPES_H 1
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 0
#define PJ_HAS_NETINET_IN_H 0
#define PJ_HAS_NETINET_TCP_H 0
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#undef PJ_HAS_STDINT_H
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 0
#define PJ_HAS_SYS_SELECT_H 0
#define PJ_HAS_SYS_SOCKET_H 0
#define PJ_HAS_SYS_TIME_H 0
#define PJ_HAS_SYS_TIMEB_H 1
#define PJ_HAS_SYS_TYPES_H 1
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 0
#define PJ_HAS_LIMITS_H 1
#define PJ_HAS_MSWSOCK_H 1
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 1
#define PJ_HAS_WS2TCPIP_H 1
#define PJ_SOCK_HAS_INET_ATON 0
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 0
/* Is errno a good way to retrieve OS errors? (No)
*/
#define PJ_HAS_ERRNO_VAR 0
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 1
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() or send() can not return immediately.
*/
#define PJ_BLOCKING_ERROR_VAL WSAEWOULDBLOCK
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL WSAEWOULDBLOCK
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_HAS_MALLOC 1
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 1
#endif
#ifdef UNICODE
# define PJ_NATIVE_STRING_IS_UNICODE 1
#else
# define PJ_NATIVE_STRING_IS_UNICODE 0
#endif
#define PJ_ATOMIC_VALUE_TYPE long
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 1
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
/* Endianness */
#if defined(_M_ARM64)
# ifndef PJ_IS_LITTLE_ENDIAN
# define PJ_IS_LITTLE_ENDIAN 1
# define PJ_IS_BIG_ENDIAN 0
# endif
#endif
#endif /* __PJ_COMPAT_OS_WIN32_H__ */

145
GSMGateway/app/src/main/cpp/pj/compat/os_win32_wince.h Normal file
View File

@@ -0,0 +1,145 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_WIN32_WINCE_H__
#define __PJ_COMPAT_OS_WIN32_WINCE_H__
/**
* @file os_win32.h
* @brief Describes Win32 operating system family specifics.
*/
#define PJ_OS_NAME "win32-wince"
#define WIN32_LEAN_AND_MEAN
#define RPC_NO_WINDOWS_H
//#define PJ_WIN32_WINNT 0x0400
//#define _WIN32_WINNT PJ_WIN32_WINNT
#define PJ_HAS_ARPA_INET_H 0
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 0 /* Must be zero, otherwise errno_test() fails. */
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 0
#define PJ_HAS_NETINET_IN_H 0
#define PJ_HAS_NETINET_TCP_H 0
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 0
#define PJ_HAS_SYS_SELECT_H 0
#define PJ_HAS_SYS_SOCKET_H 0
#define PJ_HAS_SYS_TIME_H 0
#define PJ_HAS_SYS_TIMEB_H 0 /* Doesn't have sys/timeb.h */
#define PJ_HAS_SYS_TYPES_H 0 /* Doesn't have sys/types.h */
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 0
#define PJ_HAS_MSWSOCK_H 1
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 1
#define PJ_SOCK_HAS_INET_ATON 0
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 0
/* Is errno a good way to retrieve OS errors? (no)
*/
#define PJ_HAS_ERRNO_VAR 0
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 0
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() or send() can not return immediately.
*/
#define PJ_BLOCKING_ERROR_VAL WSAEWOULDBLOCK
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL WSAEWOULDBLOCK
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* Endianness */
#ifndef PJ_IS_LITTLE_ENDIAN
# define PJ_IS_LITTLE_ENDIAN 1
# define PJ_IS_BIG_ENDIAN 0
#endif
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_HAS_MALLOC 1
#define PJ_OS_HAS_CHECK_STACK 1
#define PJ_ATOMIC_VALUE_TYPE long
/* TlsAlloc() error value. */
#define TLS_OUT_OF_INDEXES 0xFFFFFFFF
/* No console. */
#define PJ_TERM_HAS_COLOR 0
/* No rdtsc */
#define PJ_TIMESTAMP_USE_RDTSC 0
/* Native string is Unicode. */
#define PJ_NATIVE_STRING_IS_UNICODE 1
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 1
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
#endif /* __PJ_COMPAT_OS_WIN32_WINCE_H__ */

149
GSMGateway/app/src/main/cpp/pj/compat/os_winphone8.h Normal file
View File

@@ -0,0 +1,149 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_WINPHONE8_H__
#define __PJ_COMPAT_OS_WINPHONE8_H__
/**
* @file os_winphone8.h
* @brief Describes Windows Phone 8 operating system family specifics.
*/
#define PJ_OS_NAME "winphone8"
#define WIN32_LEAN_AND_MEAN
#define RPC_NO_WINDOWS_H
#define PJ_WIN32_WINNT 0x0602 /*_WIN32_WINNT_WIN8*/
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#define _WIN32_WINNT PJ_WIN32_WINNT
#endif
#define PJ_HAS_ARPA_INET_H 0
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 0 /* Must be zero, otherwise errno_test() fails. */
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 0
#define PJ_HAS_NETINET_IN_H 0
#define PJ_HAS_NETINET_TCP_H 0
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 0
#define PJ_HAS_SYS_SELECT_H 0
#define PJ_HAS_SYS_SOCKET_H 0
#define PJ_HAS_SYS_TIME_H 0
#define PJ_HAS_SYS_TIMEB_H 0 /* Doesn't have sys/timeb.h */
#define PJ_HAS_SYS_TYPES_H 0 /* Doesn't have sys/types.h */
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 0
#define PJ_HAS_MSWSOCK_H 1
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 1
#define PJ_SOCK_HAS_INET_ATON 0
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 0
/* Is errno a good way to retrieve OS errors? (no)
*/
#define PJ_HAS_ERRNO_VAR 0
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 0
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() or send() can not return immediately.
*/
#define PJ_BLOCKING_ERROR_VAL WSAEWOULDBLOCK
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL WSAEWOULDBLOCK
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* Endianness */
#ifndef PJ_IS_LITTLE_ENDIAN
# define PJ_IS_LITTLE_ENDIAN 1
# define PJ_IS_BIG_ENDIAN 0
#endif
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_HAS_MALLOC 1
#define PJ_OS_HAS_CHECK_STACK 1
#define PJ_ATOMIC_VALUE_TYPE long
/* No console. */
#define PJ_TERM_HAS_COLOR 0
/* TlsAlloc() error value. */
#ifndef TLS_OUT_OF_INDEXES
#define TLS_OUT_OF_INDEXES 0xFFFFFFFF
#endif
/* No rdtsc */
#define PJ_TIMESTAMP_USE_RDTSC 0
/* Native string is Unicode. */
#define PJ_NATIVE_STRING_IS_UNICODE 1
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 1
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
#endif /* __PJ_COMPAT_OS_WINPHONE8_H__ */

149
GSMGateway/app/src/main/cpp/pj/compat/os_winuwp.h Normal file
View File

@@ -0,0 +1,149 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_OS_UWP_H__
#define __PJ_COMPAT_OS_UWP_H__
/**
* @file os_winuwp.h
* @brief Describes Windows UWP operating system family specifics.
*/
#define PJ_OS_NAME "winuwp"
#define WIN32_LEAN_AND_MEAN
#define RPC_NO_WINDOWS_H
#define PJ_WIN32_WINNT 0x0602 /*_WIN32_WINNT_WIN8*/
#ifdef _WIN32_WINNT
#undef _WIN32_WINNT
#define _WIN32_WINNT PJ_WIN32_WINNT
#endif
#define PJ_HAS_ARPA_INET_H 0
#define PJ_HAS_ASSERT_H 1
#define PJ_HAS_CTYPE_H 1
#define PJ_HAS_ERRNO_H 0 /* Must be zero, otherwise errno_test() fails. */
#define PJ_HAS_INTTYPES_H 1
#define PJ_HAS_LINUX_SOCKET_H 0
#define PJ_HAS_MALLOC_H 1
#define PJ_HAS_NETDB_H 0
#define PJ_HAS_NETINET_IN_H 0
#define PJ_HAS_NETINET_TCP_H 0
#define PJ_HAS_SETJMP_H 1
#define PJ_HAS_STDARG_H 1
#define PJ_HAS_STDDEF_H 1
#define PJ_HAS_STDIO_H 1
#define PJ_HAS_STDLIB_H 1
#define PJ_HAS_STRING_H 1
#define PJ_HAS_SYS_IOCTL_H 0
#define PJ_HAS_SYS_SELECT_H 0
#define PJ_HAS_SYS_SOCKET_H 0
#define PJ_HAS_SYS_TIME_H 0
#define PJ_HAS_SYS_TIMEB_H 0 /* Doesn't have sys/timeb.h */
#define PJ_HAS_SYS_TYPES_H 0 /* Doesn't have sys/types.h */
#define PJ_HAS_TIME_H 1
#define PJ_HAS_UNISTD_H 0
#define PJ_HAS_LIMITS_H 1
#define PJ_HAS_MSWSOCK_H 1
#define PJ_HAS_WINSOCK_H 0
#define PJ_HAS_WINSOCK2_H 1
#define PJ_SOCK_HAS_INET_ATON 0
/* Set 1 if native sockaddr_in has sin_len member.
* Default: 0
*/
#define PJ_SOCKADDR_HAS_LEN 0
/* Is errno a good way to retrieve OS errors? (no)
*/
#define PJ_HAS_ERRNO_VAR 0
/* When this macro is set, getsockopt(SOL_SOCKET, SO_ERROR) will return
* the status of non-blocking connect() operation.
*/
#define PJ_HAS_SO_ERROR 0
/* This value specifies the value set in errno by the OS when a non-blocking
* socket recv() or send() can not return immediately.
*/
#define PJ_BLOCKING_ERROR_VAL WSAEWOULDBLOCK
/* This value specifies the value set in errno by the OS when a non-blocking
* socket connect() can not get connected immediately.
*/
#define PJ_BLOCKING_CONNECT_ERROR_VAL WSAEWOULDBLOCK
/**
* If this macro is set, it tells select I/O Queue that select() needs to
* be given correct value of nfds (i.e. largest fd + 1). This requires
* select ioqueue to re-scan the descriptors on each registration and
* unregistration.
* If this macro is not set, then ioqueue will always give FD_SETSIZE for
* nfds argument when calling select().
*
* Default: 0
*/
#define PJ_SELECT_NEEDS_NFDS 0
/* Endianness */
#ifndef PJ_IS_LITTLE_ENDIAN
# define PJ_IS_LITTLE_ENDIAN 1
# define PJ_IS_BIG_ENDIAN 0
#endif
/* Default threading is enabled, unless it's overridden. */
#ifndef PJ_HAS_THREADS
# define PJ_HAS_THREADS (1)
#endif
#define PJ_HAS_HIGH_RES_TIMER 1
#define PJ_HAS_MALLOC 1
#ifndef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
#endif
#define PJ_ATOMIC_VALUE_TYPE long
/* No console. */
#define PJ_TERM_HAS_COLOR 0
/* No rdtsc */
#define PJ_TIMESTAMP_USE_RDTSC 0
/* Native string is Unicode. */
#define PJ_NATIVE_STRING_IS_UNICODE 1
/* If 1, use Read/Write mutex emulation for platforms that don't support it */
#define PJ_EMULATE_RWMUTEX 1
/* If 1, pj_thread_create() should enforce the stack size when creating
* threads.
* Default: 0 (let OS decide the thread's stack size).
*/
#define PJ_THREAD_SET_STACK_SIZE 0
/* If 1, pj_thread_create() should allocate stack from the pool supplied.
* Default: 0 (let OS allocate memory for thread's stack).
*/
#define PJ_THREAD_ALLOCATE_STACK 0
#endif /* __PJ_COMPAT_OS_UWP_H__ */

55
GSMGateway/app/src/main/cpp/pj/compat/rand.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_RAND_H__
#define __PJ_COMPAT_RAND_H__
/**
* @file rand.h
* @brief Provides platform_rand() and platform_srand() functions.
*/
#if defined(PJ_HAS_STDLIB_H) && PJ_HAS_STDLIB_H != 0
/*
* Use stdlib based rand() and srand().
*/
# include <stdlib.h>
# define platform_srand srand
# if defined(RAND_MAX) && RAND_MAX <= 0xFFFF
/*
* When rand() is only 16 bit strong, double the strength
* by calling it twice!
*/
PJ_INLINE(int) platform_rand(void)
{
return ((rand() & 0xFFFF) << 16) | (rand() & 0xFFFF);
}
# else
# define platform_rand rand
# endif
#else
# warning "platform_rand() is not implemented"
# define platform_rand() 1
# define platform_srand(seed)
#endif
#endif /* __PJ_COMPAT_RAND_H__ */

49
GSMGateway/app/src/main/cpp/pj/compat/setjmp.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_SETJMP_H__
#define __PJ_COMPAT_SETJMP_H__
/**
* @file setjmp.h
* @brief Provides setjmp.h functionality.
*/
#if defined(PJ_HAS_SETJMP_H) && PJ_HAS_SETJMP_H != 0
# include <setjmp.h>
typedef jmp_buf pj_jmp_buf;
# ifndef pj_setjmp
# define pj_setjmp(buf) setjmp(buf)
# endif
# ifndef pj_longjmp
# define pj_longjmp(buf,d) longjmp(buf,d)
# endif
#elif defined(PJ_SYMBIAN) && PJ_SYMBIAN!=0
/* Symbian framework don't use setjmp/longjmp */
#else
# warning "setjmp()/longjmp() is not implemented"
typedef int pj_jmp_buf[1];
# define pj_setjmp(buf) 0
# define pj_longjmp(buf,d) 0
#endif
#endif /* __PJ_COMPAT_SETJMP_H__ */

31
GSMGateway/app/src/main/cpp/pj/compat/size_t.h Normal file
View File

@@ -0,0 +1,31 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_SIZE_T_H__
#define __PJ_COMPAT_SIZE_T_H__
/**
* @file size_t.h
* @brief Provides size_t type.
*/
#if PJ_HAS_STDDEF_H
# include <stddef.h>
#endif
#endif /* __PJ_COMPAT_SIZE_T_H__ */

223
GSMGateway/app/src/main/cpp/pj/compat/socket.h Normal file
View File

@@ -0,0 +1,223 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_SOCKET_H__
#define __PJ_COMPAT_SOCKET_H__
/**
* @file socket.h
* @brief Provides all socket related functions,data types, error codes, etc.
*/
#if defined(PJ_HAS_WINSOCK2_H) && PJ_HAS_WINSOCK2_H != 0
# include <winsock2.h>
#endif
#if defined(PJ_HAS_WINSOCK_H) && PJ_HAS_WINSOCK_H != 0
# include <winsock.h>
#endif
#if defined(PJ_HAS_WS2TCPIP_H) && PJ_HAS_WS2TCPIP_H != 0
# include <ws2tcpip.h>
#endif
#if (defined(PJ_WIN32_UWP) && PJ_WIN32_UWP!=0)
# include <in6addr.h>
#endif
/*
* IPv6 for Visual Studio's
*
* = Visual Studio 6 =
*
* Visual Studio 6 does not ship with IPv6 support, so you MUST
* download and install IPv6 Tehnology Preview (IPv6Kit) from:
* http://msdn.microsoft.com/downloads/sdks/platform/tpipv6/ReadMe.asp
* Then put IPv6Kit\inc in your Visual Studio include path.
*
* In addition, by default IPv6Kit does not want to install on
* Windows 2000 SP4. Please see:
* http://msdn.microsoft.com/downloads/sdks/platform/tpipv6/faq.asp
* on how to install IPv6Kit on Win2K SP4.
*
*
* = Visual Studio 2003, 2005 (including Express) =
*
* These VS uses Microsoft Platform SDK for Windows Server 2003 SP1, and
* it has built-in IPv6 support.
*/
#if defined(_MSC_VER) && defined(PJ_HAS_IPV6) && PJ_HAS_IPV6!=0
# ifndef s_addr
# define s_addr S_un.S_addr
# endif
# if !defined(IPPROTO_IPV6) && (_WIN32_WINNT == 0x0500)
/* Need to download and install IPv6Kit for this platform.
* Please see the comments above about Visual Studio 6.
*/
# include <tpipv6.h>
# endif
# define PJ_SOCK_HAS_GETADDRINFO 1
#endif /* _MSC_VER */
#if defined(PJ_HAS_SYS_TYPES_H) && PJ_HAS_SYS_TYPES_H != 0
# include <sys/types.h>
#endif
#if defined(PJ_HAS_SYS_SOCKET_H) && PJ_HAS_SYS_SOCKET_H != 0
# include <sys/socket.h>
#endif
#if defined(PJ_HAS_LINUX_SOCKET_H) && PJ_HAS_LINUX_SOCKET_H != 0
# include <linux/socket.h>
#endif
#if defined(PJ_HAS_SYS_SELECT_H) && PJ_HAS_SYS_SELECT_H != 0
# include <sys/select.h>
#endif
#if defined(PJ_HAS_NETINET_IN_H) && PJ_HAS_NETINET_IN_H != 0
# include <netinet/in.h>
#endif
#if defined(PJ_HAS_NETINET_IN_SYSTM_H) && PJ_HAS_NETINET_IN_SYSTM_H != 0
/* Required to include netinet/ip.h in FreeBSD 7.0 */
# include <netinet/in_systm.h>
#endif
#if defined(PJ_HAS_NETINET_IP_H) && PJ_HAS_NETINET_IP_H != 0
/* To pull in IPTOS_* constants */
# include <netinet/ip.h>
#endif
#if defined(PJ_HAS_NETINET_TCP_H) && PJ_HAS_NETINET_TCP_H != 0
/* To pull in TCP_NODELAY constants */
# include <netinet/tcp.h>
#endif
#if defined(PJ_HAS_NET_IF_H) && PJ_HAS_NET_IF_H != 0
/* For interface enumeration in ip_helper */
# include <net/if.h>
#endif
#if defined(PJ_HAS_IFADDRS_H) && PJ_HAS_IFADDRS_H != 0
/* Interface enum with getifaddrs() which works with IPv6 */
# include <ifaddrs.h>
#endif
#if defined(PJ_HAS_ARPA_INET_H) && PJ_HAS_ARPA_INET_H != 0
# include <arpa/inet.h>
#endif
#if defined(PJ_HAS_SYS_IOCTL_H) && PJ_HAS_SYS_IOCTL_H != 0
# include <sys/ioctl.h> /* FBIONBIO */
#endif
#if defined(PJ_HAS_ERRNO_H) && PJ_HAS_ERRNO_H != 0
# include <errno.h>
#endif
#if defined(PJ_HAS_NETDB_H) && PJ_HAS_NETDB_H != 0
# include <netdb.h>
#endif
#if defined(PJ_HAS_UNISTD_H) && PJ_HAS_UNISTD_H != 0
# include <unistd.h>
#endif
#if defined(PJ_HAS_SYS_FILIO_H) && PJ_HAS_SYS_FILIO_H != 0
# include <sys/filio.h>
#endif
#if defined(PJ_HAS_SYS_SOCKIO_H) && PJ_HAS_SYS_SOCKIO_H != 0
# include <sys/sockio.h>
#endif
/*
* Define common errors.
*/
#if (defined(PJ_WIN32) && PJ_WIN32!=0) || \
(defined(PJ_WIN32_WINCE) && PJ_WIN32_WINCE!=0) || \
(defined(PJ_WIN64) && PJ_WIN64!=0)
# define OSERR_EWOULDBLOCK WSAEWOULDBLOCK
# define OSERR_EINPROGRESS WSAEINPROGRESS
# define OSERR_ECONNRESET WSAECONNRESET
# define OSERR_ENOTCONN WSAENOTCONN
# define OSERR_EAFNOSUPPORT WSAEAFNOSUPPORT
# define OSERR_ENOPROTOOPT WSAENOPROTOOPT
#elif defined(PJ_SYMBIAN) && PJ_SYMBIAN!=0
# define OSERR_EWOULDBLOCK -1
# define OSERR_EINPROGRESS -1
# define OSERR_ECONNRESET -1
# define OSERR_ENOTCONN -1
# define OSERR_EAFNOSUPPORT -1
# define OSERR_ENOPROTOOPT -1
#else
# define OSERR_EWOULDBLOCK EWOULDBLOCK
# define OSERR_EINPROGRESS EINPROGRESS
# define OSERR_ECONNRESET ECONNRESET
# define OSERR_ENOTCONN ENOTCONN
# define OSERR_EAFNOSUPPORT EAFNOSUPPORT
# define OSERR_ENOPROTOOPT ENOPROTOOPT
#endif
/*
* And undefine these..
* Note (see issue #2311): unfortunately, this may cause build failure
* to anyone who uses these standard macros.
*/
//#undef s_addr
//#undef s6_addr
//#undef sin_zero
/*
* This will finally be obsoleted, since it should be declared in
* os_auto.h
*/
#if !defined(PJ_HAS_SOCKLEN_T) || PJ_HAS_SOCKLEN_T==0
typedef int socklen_t;
#endif
/* Regarding sin_len member of sockaddr_in:
* BSD systems (including MacOS X requires that the sin_len member of
* sockaddr_in be set to sizeof(sockaddr_in), while other systems (Windows
* and Linux included) do not.
*
* To maintain compatibility between systems, PJLIB will automatically
* set this field before invoking native OS socket API, and it will
* always reset the field to zero before returning pj_sockaddr_in to
* application (such as in pj_getsockname() and pj_recvfrom()).
*
* Application MUST always set this field to zero.
*
* This way we can avoid hard to find problem such as when the socket
* address is used as hash table key.
*/
#if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
# define PJ_SOCKADDR_SET_LEN(addr,len) (((pj_addr_hdr*)(addr))->sa_zero_len=(len))
# define PJ_SOCKADDR_RESET_LEN(addr) (((pj_addr_hdr*)(addr))->sa_zero_len=0)
#else
# define PJ_SOCKADDR_SET_LEN(addr,len)
# define PJ_SOCKADDR_RESET_LEN(addr)
#endif
#endif /* __PJ_COMPAT_SOCKET_H__ */

31
GSMGateway/app/src/main/cpp/pj/compat/stdarg.h Normal file
View File

@@ -0,0 +1,31 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_STDARG_H__
#define __PJ_COMPAT_STDARG_H__
/**
* @file stdarg.h
* @brief Provides stdarg functionality.
*/
#if defined(PJ_HAS_STDARG_H) && PJ_HAS_STDARG_H != 0
# include <stdarg.h>
#endif
#endif /* __PJ_COMPAT_STDARG_H__ */

31
GSMGateway/app/src/main/cpp/pj/compat/stdfileio.h Normal file
View File

@@ -0,0 +1,31 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_STDFILEIO_H__
#define __PJ_COMPAT_STDFILEIO_H__
/**
* @file stdfileio.h
* @brief Compatibility for ANSI file I/O like fputs, fflush, etc.
*/
#if defined(PJ_HAS_STDIO_H) && PJ_HAS_STDIO_H != 0
# include <stdio.h>
#endif
#endif /* __PJ_COMPAT_STDFILEIO_H__ */

178
GSMGateway/app/src/main/cpp/pj/compat/string.h Normal file
View File

@@ -0,0 +1,178 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_STRING_H__
#define __PJ_COMPAT_STRING_H__
/**
* @file string.h
* @brief Provides string manipulation functions found in ANSI string.h.
*/
#if defined(PJ_HAS_STRING_H) && PJ_HAS_STRING_H != 0
# include <string.h>
#else
PJ_DECL(int) strcasecmp(const char *s1, const char *s2);
PJ_DECL(int) strncasecmp(const char *s1, const char *s2, int len);
#endif
/* For sprintf family */
#include <stdio.h>
/* On WinCE, string stuffs are declared in stdlib.h */
#if defined(PJ_HAS_STDLIB_H) && PJ_HAS_STDLIB_H!=0
# include <stdlib.h>
#endif
#if defined(_MSC_VER)
# define strcasecmp _stricmp
# define strncasecmp _strnicmp
/* snprintf() and vsnprintf() are available since Visual Studio 2015 */
#if _MSC_VER < 1900
# define snprintf _snprintf
# define vsnprintf _vsnprintf
#endif
# define snwprintf _snwprintf
# define wcsicmp _wcsicmp
# define wcsnicmp _wcsnicmp
#else
# define stricmp strcasecmp
# define strnicmp strncasecmp
# if defined(PJ_NATIVE_STRING_IS_UNICODE) && PJ_NATIVE_STRING_IS_UNICODE!=0
# error "Implement Unicode string functions"
# endif
#endif
#define pj_ansi_strcmp strcmp
#define pj_ansi_strncmp strncmp
#define pj_ansi_strlen strlen
#if defined(PJ_BAN_STRCPY) && PJ_BAN_STRCPY
/* Use pj_ansi_strxcpy() instead */
# define strcpy error__strcpy_is_banned
# define pj_ansi_strcpy error__strcpy_is_banned
#else
# define pj_ansi_strcpy strcpy
#endif
#if defined(PJ_BAN_STRNCPY) && PJ_BAN_STRNCPY
/* Use pj_ansi_strxcpy() instead */
# define strncpy error__strncpy_is_banned
# define pj_ansi_strncpy error__strncpy_is_banned
#else
# define pj_ansi_strncpy strncpy
#endif
#if defined(PJ_BAN_STRCAT) && PJ_BAN_STRCAT
/* Use pj_ansi_strxcat() instead */
# define strcat error__strcat_is_banned
# define pj_ansi_strcat error__strcat_is_banned
#else
# define pj_ansi_strcat strcat
#endif
#define pj_ansi_strstr strstr
#define pj_ansi_strchr strchr
#define pj_ansi_strcasecmp strcasecmp
#define pj_ansi_stricmp strcasecmp
#define pj_ansi_strncasecmp strncasecmp
#define pj_ansi_strnicmp strncasecmp
#if defined(PJ_BAN_SPRINTF) && PJ_BAN_SPRINTF
/* Use pj_ansi_snprintf() instead */
# define sprintf error__sprintf_is_banned
# define pj_ansi_sprintf error__sprintf_is_banned
#else
# define pj_ansi_sprintf sprintf
#endif
#if defined(PJ_HAS_NO_SNPRINTF) && PJ_HAS_NO_SNPRINTF != 0
# include <pj/types.h>
# include <pj/compat/stdarg.h>
PJ_BEGIN_DECL
PJ_DECL(int) snprintf(char*s1, pj_size_t len, const char*s2, ...);
PJ_DECL(int) vsnprintf(char*s1, pj_size_t len, const char*s2, va_list arg);
PJ_END_DECL
#endif
#define pj_ansi_snprintf snprintf
#if defined(PJ_BAN_VSPRINTF) && PJ_BAN_VSPRINTF
/* Use pj_ansi_vsnprintf() instead */
# define vsprintf error__vsprintf_is_banned
# define pj_ansi_vsprintf error__vsprintf_is_banned
#else
# define pj_ansi_vsprintf vsprintf
#endif
#define pj_ansi_vsnprintf vsnprintf
#define pj_unicode_strcmp wcscmp
#define pj_unicode_strncmp wcsncmp
#define pj_unicode_strlen wcslen
#define pj_unicode_strcpy wcscpy
#define pj_unicode_strncpy wcsncpy
#define pj_unicode_strcat wcscat
#define pj_unicode_strstr wcsstr
#define pj_unicode_strchr wcschr
#define pj_unicode_strcasecmp wcsicmp
#define pj_unicode_stricmp wcsicmp
#define pj_unicode_strncasecmp wcsnicmp
#define pj_unicode_strnicmp wcsnicmp
#define pj_unicode_sprintf swprintf
#define pj_unicode_snprintf snwprintf
#define pj_unicode_vsprintf vswprintf
#define pj_unicode_vsnprintf vsnwprintf
#if defined(PJ_NATIVE_STRING_IS_UNICODE) && PJ_NATIVE_STRING_IS_UNICODE!=0
# define pj_native_strcmp pj_unicode_strcmp
# define pj_native_strncmp pj_unicode_strncmp
# define pj_native_strlen pj_unicode_strlen
# define pj_native_strcpy pj_unicode_strcpy
# define pj_native_strncpy pj_unicode_strncpy
# define pj_native_strcat pj_unicode_strcat
# define pj_native_strstr pj_unicode_strstr
# define pj_native_strchr pj_unicode_strchr
# define pj_native_strcasecmp pj_unicode_strcasecmp
# define pj_native_stricmp pj_unicode_stricmp
# define pj_native_strncasecmp pj_unicode_strncasecmp
# define pj_native_strnicmp pj_unicode_strnicmp
# define pj_native_sprintf pj_unicode_sprintf
# define pj_native_snprintf pj_unicode_snprintf
# define pj_native_vsprintf pj_unicode_vsprintf
# define pj_native_vsnprintf pj_unicode_vsnprintf
#else
# define pj_native_strcmp pj_ansi_strcmp
# define pj_native_strncmp pj_ansi_strncmp
# define pj_native_strlen pj_ansi_strlen
# define pj_native_strcpy pj_ansi_strcpy
# define pj_native_strncpy pj_ansi_strncpy
# define pj_native_strcat pj_ansi_strcat
# define pj_native_strstr pj_ansi_strstr
# define pj_native_strchr pj_ansi_strchr
# define pj_native_strcasecmp pj_ansi_strcasecmp
# define pj_native_stricmp pj_ansi_stricmp
# define pj_native_strncasecmp pj_ansi_strncasecmp
# define pj_native_strnicmp pj_ansi_strnicmp
# define pj_native_sprintf pj_ansi_sprintf
# define pj_native_snprintf pj_ansi_snprintf
# define pj_native_vsprintf pj_ansi_vsprintf
# define pj_native_vsnprintf pj_ansi_vsnprintf
#endif
#endif /* __PJ_COMPAT_STRING_H__ */

41
GSMGateway/app/src/main/cpp/pj/compat/time.h Normal file
View File

@@ -0,0 +1,41 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_COMPAT_TIME_H__
#define __PJ_COMPAT_TIME_H__
/**
* @file time.h
* @brief Provides ftime() and localtime() etc functions.
*/
#if defined(PJ_HAS_TIME_H) && PJ_HAS_TIME_H != 0
# include <time.h>
#endif
#if defined(PJ_HAS_SYS_TIME_H) && PJ_HAS_SYS_TIME_H != 0
# include <sys/time.h>
#endif
#if defined(PJ_HAS_SYS_TIMEB_H) && PJ_HAS_SYS_TIMEB_H != 0
# include <sys/timeb.h>
#endif
#endif /* __PJ_COMPAT_TIME_H__ */

1537
GSMGateway/app/src/main/cpp/pj/config.h Normal file
View File

File diff suppressed because it is too large Load Diff

0
GSMGateway/app/src/main/cpp/pj/config_site.h Normal file
View File

485
GSMGateway/app/src/main/cpp/pj/config_site_sample.h Normal file
View File

@@ -0,0 +1,485 @@
/*
* This file contains several sample settings especially for Windows
* Mobile and Symbian targets. You can include this file in your
* <pj/config_site.h> file.
*
* The Windows Mobile and Symbian settings will be activated
* automatically if you include this file.
*
* In addition, you may specify one of these macros (before including
* this file) to activate additional settings:
*
* #define PJ_CONFIG_NOKIA_APS_DIRECT
* Use this macro to activate the APS-Direct feature. Please see
* http://trac.pjsip.org/repos/wiki/Nokia_APS_VAS_Direct for more
* info.
*
* #define PJ_CONFIG_WIN32_WMME_DIRECT
* Configuration to activate "APS-Direct" media mode on Windows or
* Windows Mobile, useful for testing purposes only.
*/
/*
* Typical configuration for WinCE target.
*/
#if defined(PJ_WIN32_WINCE) && PJ_WIN32_WINCE!=0
/*
* PJLIB settings.
*/
/* Disable floating point support */
#define PJ_HAS_FLOATING_POINT 0
/*
* PJMEDIA settings
*/
/* Select codecs to disable */
#define PJMEDIA_HAS_L16_CODEC 0
#define PJMEDIA_HAS_ILBC_CODEC 0
/* We probably need more buffers on WM, so increase the limit */
#define PJMEDIA_SOUND_BUFFER_COUNT 32
/* Fine tune Speex's default settings for best performance/quality */
#define PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY 5
/* For CPU reason, disable speex AEC and use the echo suppressor. */
#define PJMEDIA_HAS_SPEEX_AEC 0
/* Previously, resampling is disabled due to performance reason and
* this condition prevented some 'light' wideband codecs (e.g: G722.1)
* to work along with narrowband codecs. Lately, some tests showed
* that 16kHz <-> 8kHz resampling using libresample small filter was
* affordable on ARM9 260 MHz, so here we decided to enable resampling.
* Note that it is important to make sure that libresample is created
* using small filter. For example PJSUA_DEFAULT_CODEC_QUALITY must
* be set to 3 or 4 so pjsua-lib will apply small filter resampling.
*/
//#define PJMEDIA_RESAMPLE_IMP PJMEDIA_RESAMPLE_NONE
#define PJMEDIA_RESAMPLE_IMP PJMEDIA_RESAMPLE_LIBRESAMPLE
/* Use the lighter WSOLA implementation */
#define PJMEDIA_WSOLA_IMP PJMEDIA_WSOLA_IMP_WSOLA_LITE
/*
* PJSIP settings.
*/
/* Set maximum number of dialog/transaction/calls to minimum to reduce
* memory usage
*/
#define PJSIP_MAX_TSX_COUNT 31
#define PJSIP_MAX_DIALOG_COUNT 31
#define PJSUA_MAX_CALLS 4
/*
* PJSUA settings
*/
/* Default codec quality, previously was set to 5, however it is now
* set to 4 to make sure pjsua instantiates resampler with small filter.
*/
#define PJSUA_DEFAULT_CODEC_QUALITY 4
/* Set maximum number of objects to minimum to reduce memory usage */
#define PJSUA_MAX_ACC 4
#define PJSUA_MAX_PLAYERS 4
#define PJSUA_MAX_RECORDERS 4
#define PJSUA_MAX_CONF_PORTS (PJSUA_MAX_CALLS+2*PJSUA_MAX_PLAYERS)
#define PJSUA_MAX_BUDDIES 32
#endif /* PJ_WIN32_WINCE */
/*
* Typical configuration for Symbian OS target
*/
#if defined(PJ_SYMBIAN) && PJ_SYMBIAN!=0
/*
* PJLIB settings.
*/
/* Disable floating point support */
#define PJ_HAS_FLOATING_POINT 0
/* Misc PJLIB setting */
#define PJ_MAXPATH 80
/* This is important for Symbian. Symbian lacks vsnprintf(), so
* if the log buffer is not long enough it's possible that
* large incoming packet will corrupt memory when the log tries
* to log the packet.
*/
#define PJ_LOG_MAX_SIZE (PJSIP_MAX_PKT_LEN+500)
/* Since we don't have threads, log buffer can use static buffer
* rather than stack
*/
#define PJ_LOG_USE_STACK_BUFFER 0
/* Disable check stack since it increases footprint */
#define PJ_OS_HAS_CHECK_STACK 0
/*
* PJMEDIA settings
*/
/* Disable non-Symbian audio devices */
#define PJMEDIA_AUDIO_DEV_HAS_PORTAUDIO 0
#define PJMEDIA_AUDIO_DEV_HAS_WMME 0
/* Select codecs to disable */
#define PJMEDIA_HAS_L16_CODEC 0
#define PJMEDIA_HAS_ILBC_CODEC 0
#define PJMEDIA_HAS_G722_CODEC 0
/* Fine tune Speex's default settings for best performance/quality */
#define PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY 5
/* For CPU reason, disable speex AEC and use the echo suppressor. */
#define PJMEDIA_HAS_SPEEX_AEC 0
/* Previously, resampling is disabled due to performance reason and
* this condition prevented some 'light' wideband codecs (e.g: G722.1)
* to work along with narrowband codecs. Lately, some tests showed
* that 16kHz <-> 8kHz resampling using libresample small filter was
* affordable on ARM9 222 MHz, so here we decided to enable resampling.
* Note that it is important to make sure that libresample is created
* using small filter. For example PJSUA_DEFAULT_CODEC_QUALITY must
* be set to 3 or 4 so pjsua-lib will apply small filter resampling.
*/
//#define PJMEDIA_RESAMPLE_IMP PJMEDIA_RESAMPLE_NONE
#define PJMEDIA_RESAMPLE_IMP PJMEDIA_RESAMPLE_LIBRESAMPLE
/* Use the lighter WSOLA implementation */
#define PJMEDIA_WSOLA_IMP PJMEDIA_WSOLA_IMP_WSOLA_LITE
/* We probably need more buffers especially if MDA audio backend
* is used, so increase the limit
*/
#define PJMEDIA_SOUND_BUFFER_COUNT 32
/*
* PJSIP settings.
*/
/* Disable safe module access, since we don't use multithreading */
#define PJSIP_SAFE_MODULE 0
/* Use large enough packet size */
#define PJSIP_MAX_PKT_LEN 2000
/* Symbian has problem with too many large blocks */
#define PJSIP_POOL_LEN_ENDPT 1000
#define PJSIP_POOL_INC_ENDPT 1000
#define PJSIP_POOL_RDATA_LEN 2000
#define PJSIP_POOL_RDATA_INC 2000
#define PJSIP_POOL_LEN_TDATA 2000
#define PJSIP_POOL_INC_TDATA 512
#define PJSIP_POOL_LEN_UA 2000
#define PJSIP_POOL_INC_UA 1000
#define PJSIP_POOL_TSX_LAYER_LEN 256
#define PJSIP_POOL_TSX_LAYER_INC 256
#define PJSIP_POOL_TSX_LEN 512
#define PJSIP_POOL_TSX_INC 128
/*
* PJSUA settings.
*/
/* Default codec quality, previously was set to 5, however it is now
* set to 4 to make sure pjsua instantiates resampler with small filter.
*/
#define PJSUA_DEFAULT_CODEC_QUALITY 4
/* Set maximum number of dialog/transaction/calls to minimum */
#define PJSIP_MAX_TSX_COUNT 31
#define PJSIP_MAX_DIALOG_COUNT 31
#define PJSUA_MAX_CALLS 4
/* Other pjsua settings */
#define PJSUA_MAX_ACC 4
#define PJSUA_MAX_PLAYERS 4
#define PJSUA_MAX_RECORDERS 4
#define PJSUA_MAX_CONF_PORTS (PJSUA_MAX_CALLS+2*PJSUA_MAX_PLAYERS)
#define PJSUA_MAX_BUDDIES 32
#endif
/*
* Additional configuration to activate APS-Direct feature for
* Nokia S60 target
*
* Please see http://trac.pjsip.org/repos/wiki/Nokia_APS_VAS_Direct
*/
#ifdef PJ_CONFIG_NOKIA_APS_DIRECT
/* MUST use switchboard rather than the conference bridge */
#define PJMEDIA_CONF_USE_SWITCH_BOARD 1
/* Enable APS sound device backend and disable MDA & VAS */
#define PJMEDIA_AUDIO_DEV_HAS_SYMB_MDA 0
#define PJMEDIA_AUDIO_DEV_HAS_SYMB_APS 1
#define PJMEDIA_AUDIO_DEV_HAS_SYMB_VAS 0
/* Enable passthrough codec framework */
#define PJMEDIA_HAS_PASSTHROUGH_CODECS 1
/* And selectively enable which codecs are supported by the handset */
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_PCMU 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_PCMA 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_AMR 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_G729 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_ILBC 1
#endif
/*
* Additional configuration to activate VAS-Direct feature for
* Nokia S60 target
*
* Please see http://trac.pjsip.org/repos/wiki/Nokia_APS_VAS_Direct
*/
#ifdef PJ_CONFIG_NOKIA_VAS_DIRECT
/* MUST use switchboard rather than the conference bridge */
#define PJMEDIA_CONF_USE_SWITCH_BOARD 1
/* Enable VAS sound device backend and disable MDA & APS */
#define PJMEDIA_AUDIO_DEV_HAS_SYMB_MDA 0
#define PJMEDIA_AUDIO_DEV_HAS_SYMB_APS 0
#define PJMEDIA_AUDIO_DEV_HAS_SYMB_VAS 1
/* Enable passthrough codec framework */
#define PJMEDIA_HAS_PASSTHROUGH_CODECS 1
/* And selectively enable which codecs are supported by the handset */
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_PCMU 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_PCMA 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_AMR 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_G729 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_ILBC 1
#endif
/*
* Configuration to activate "APS-Direct" media mode on Windows,
* useful for testing purposes only.
*/
#ifdef PJ_CONFIG_WIN32_WMME_DIRECT
/* MUST use switchboard rather than the conference bridge */
#define PJMEDIA_CONF_USE_SWITCH_BOARD 1
/* Only WMME supports the "direct" feature */
#define PJMEDIA_AUDIO_DEV_HAS_PORTAUDIO 0
#define PJMEDIA_AUDIO_DEV_HAS_WMME 1
/* Enable passthrough codec framework */
#define PJMEDIA_HAS_PASSTHROUGH_CODECS 1
/* Only PCMA and PCMU are supported by WMME-direct */
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_PCMU 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_PCMA 1
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_AMR 0
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_G729 0
#define PJMEDIA_HAS_PASSTHROUGH_CODEC_ILBC 0
#endif
/*
* iPhone sample settings.
*/
#if PJ_CONFIG_IPHONE
/*
* PJLIB settings.
*/
/* Both armv6 and armv7 has FP hardware support.
* See https://github.com/pjsip/pjproject/issues/1589 for more info
*/
#define PJ_HAS_FLOATING_POINT 1
/*
* PJMEDIA settings
*/
/* We have our own native CoreAudio backend */
#define PJMEDIA_AUDIO_DEV_HAS_PORTAUDIO 0
#define PJMEDIA_AUDIO_DEV_HAS_WMME 0
#define PJMEDIA_AUDIO_DEV_HAS_COREAUDIO 1
/* The CoreAudio backend has built-in echo canceller! */
#define PJMEDIA_HAS_SPEEX_AEC 0
/* Disable some codecs */
#define PJMEDIA_HAS_L16_CODEC 0
//#define PJMEDIA_HAS_G722_CODEC 0
/* Use the built-in CoreAudio's iLBC codec (yay!) */
#define PJMEDIA_HAS_ILBC_CODEC 1
#define PJMEDIA_ILBC_CODEC_USE_COREAUDIO 1
/* Fine tune Speex's default settings for best performance/quality */
#define PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY 5
/*
* PJSIP settings.
*/
/* Increase allowable packet size, just in case */
//#define PJSIP_MAX_PKT_LEN 2000
/*
* PJSUA settings.
*/
/* Default codec quality, previously was set to 5, however it is now
* set to 4 to make sure pjsua instantiates resampler with small filter.
*/
#define PJSUA_DEFAULT_CODEC_QUALITY 4
/* Set maximum number of dialog/transaction/calls to minimum */
#define PJSIP_MAX_TSX_COUNT 31
#define PJSIP_MAX_DIALOG_COUNT 31
#define PJSUA_MAX_CALLS 4
/* Other pjsua settings */
#define PJSUA_MAX_ACC 4
#define PJSUA_MAX_PLAYERS 4
#define PJSUA_MAX_RECORDERS 4
#define PJSUA_MAX_CONF_PORTS (PJSUA_MAX_CALLS+2*PJSUA_MAX_PLAYERS)
#define PJSUA_MAX_BUDDIES 32
#endif
/*
* Android sample settings.
*/
#if PJ_CONFIG_ANDROID
/*
* PJLIB settings.
*/
/* Disable floating point support */
#undef PJ_HAS_FLOATING_POINT
#define PJ_HAS_FLOATING_POINT 0
/*
* PJMEDIA settings
*/
/* We have our own OpenSL ES backend */
#define PJMEDIA_AUDIO_DEV_HAS_PORTAUDIO 0
#define PJMEDIA_AUDIO_DEV_HAS_WMME 0
#define PJMEDIA_AUDIO_DEV_HAS_OPENSL 0
#define PJMEDIA_AUDIO_DEV_HAS_ANDROID_JNI 1
/* Disable some codecs */
#define PJMEDIA_HAS_L16_CODEC 0
//#define PJMEDIA_HAS_G722_CODEC 0
/* Fine tune Speex's default settings for best performance/quality */
#define PJMEDIA_CODEC_SPEEX_DEFAULT_QUALITY 5
/*
* PJSIP settings.
*/
/* Increase allowable packet size, just in case */
//#define PJSIP_MAX_PKT_LEN 2000
/*
* PJSUA settings.
*/
/* Default codec quality, previously was set to 5, however it is now
* set to 4 to make sure pjsua instantiates resampler with small filter.
*/
#define PJSUA_DEFAULT_CODEC_QUALITY 4
/* Set maximum number of dialog/transaction/calls to minimum */
#define PJSIP_MAX_TSX_COUNT 31
#define PJSIP_MAX_DIALOG_COUNT 31
#define PJSUA_MAX_CALLS 4
/* Separate worker thread for timer and ioqueue */
// #define PJSUA_SEPARATE_WORKER_FOR_TIMER 1
/* Other pjsua settings */
#define PJSUA_MAX_ACC 4
#define PJSUA_MAX_PLAYERS 4
#define PJSUA_MAX_RECORDERS 4
#define PJSUA_MAX_CONF_PORTS (PJSUA_MAX_CALLS+2*PJSUA_MAX_PLAYERS)
#define PJSUA_MAX_BUDDIES 32
#endif
/*
* BB10
*/
#if defined(PJ_CONFIG_BB10) && PJ_CONFIG_BB10
/* Quality 3 - 4 to use resampling small filter */
#define PJSUA_DEFAULT_CODEC_QUALITY 4
#define PJMEDIA_HAS_LEGACY_SOUND_API 0
#undef PJMEDIA_HAS_SPEEX_AEC
#define PJMEDIA_HAS_SPEEX_AEC 0
#undef PJMEDIA_AUDIO_DEV_HAS_PORTAUDIO
#define PJMEDIA_AUDIO_DEV_HAS_PORTAUDIO 0
#undef PJMEDIA_AUDIO_DEV_HAS_ALSA
#define PJMEDIA_AUDIO_DEV_HAS_ALSA 0
#endif
/*
* Minimum size
*/
#ifdef PJ_CONFIG_MINIMAL_SIZE
# undef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
# define PJ_LOG_MAX_LEVEL 0
# define PJ_HAS_ERROR_STRING 0
# undef PJ_IOQUEUE_MAX_HANDLES
/* Putting max handles to lower than 32 will make pj_fd_set_t size smaller
* than native fdset_t and will trigger assertion on sock_select.c.
*/
# define PJ_IOQUEUE_MAX_HANDLES 32
# define PJ_CRC32_HAS_TABLES 0
# define PJSIP_MAX_TSX_COUNT 15
# define PJSIP_MAX_DIALOG_COUNT 15
# define PJSIP_UDP_SO_SNDBUF_SIZE 4000
# define PJSIP_UDP_SO_RCVBUF_SIZE 4000
# define PJMEDIA_HAS_ALAW_ULAW_TABLE 0
#elif defined(PJ_CONFIG_MAXIMUM_SPEED)
# define PJ_SCANNER_USE_BITWISE 0
# undef PJ_OS_HAS_CHECK_STACK
# define PJ_OS_HAS_CHECK_STACK 0
# define PJ_LOG_MAX_LEVEL 3
# define PJ_IOQUEUE_MAX_HANDLES 5000
# define PJSIP_MAX_TSX_COUNT ((640*1024)-1)
# define PJSIP_MAX_DIALOG_COUNT ((640*1024)-1)
# define PJSIP_UDP_SO_SNDBUF_SIZE (24*1024*1024)
# define PJSIP_UDP_SO_RCVBUF_SIZE (24*1024*1024)
# define PJ_DEBUG 0
# define PJSIP_SAFE_MODULE 0
# define PJ_HAS_STRICMP_ALNUM 0
# define PJSIP_UNESCAPE_IN_PLACE 1
# if defined(PJ_WIN32) || defined(PJ_WIN64)
# define PJSIP_MAX_NET_EVENTS 10
# endif
# define PJSUA_MAX_CALLS 512
#endif

11
GSMGateway/app/src/main/cpp/pj/config_site_test.h Normal file
View File

@@ -0,0 +1,11 @@
#define PJMEDIA_SRTP_HAS_DTLS 1
#define PJMEDIA_HAS_WEBRTC_AEC 1
#define PJMEDIA_CODEC_L16_HAS_8KHZ_MONO 1
#define PJMEDIA_CODEC_L16_HAS_8KHZ_STEREO 1
#define PJMEDIA_CODEC_L16_HAS_16KHZ_MONO 1
#define PJMEDIA_CODEC_L16_HAS_16KHZ_STEREO 1
#define PJMEDIA_CODEC_L16_HAS_48KHZ_MONO 1
#define PJMEDIA_CODEC_L16_HAS_48KHZ_STEREO 1
#define PJMEDIA_HAS_G7221_CODEC 1
#define PJMEDIA_HAS_G722_CODEC 1
#define PJ_EXCLUDE_BENCHMARK_TESTS 1

174
GSMGateway/app/src/main/cpp/pj/ctype.h Normal file
View File

@@ -0,0 +1,174 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_CTYPE_H__
#define __PJ_CTYPE_H__
/**
* @file ctype.h
* @brief C type helper macros.
*/
#include <pj/types.h>
#include <pj/compat/ctype.h>
PJ_BEGIN_DECL
/**
* @defgroup pj_ctype ctype - Character Type
* @ingroup PJ_MISC
* @{
*
* This module contains several inline functions/macros for testing or
* manipulating character types. It is provided in PJLIB because PJLIB
* must not depend to LIBC.
*/
/**
* Returns a non-zero value if either isalpha or isdigit is true for c.
* @param c The integer character to test.
* @return Non-zero value if either isalpha or isdigit is true for c.
*/
PJ_INLINE(int) pj_isalnum(unsigned char c) { return isalnum(c); }
/**
* Returns a non-zero value if c is a particular representation of an
* alphabetic character.
* @param c The integer character to test.
* @return Non-zero value if c is a particular representation of an
* alphabetic character.
*/
PJ_INLINE(int) pj_isalpha(unsigned char c) { return isalpha(c); }
/**
* Returns a non-zero value if c is a particular representation of an
* ASCII character.
* @param c The integer character to test.
* @return Non-zero value if c is a particular representation of
* an ASCII character.
*/
PJ_INLINE(int) pj_isascii(unsigned char c) { return c<128; }
/**
* Returns a non-zero value if c is a particular representation of
* a decimal-digit character.
* @param c The integer character to test.
* @return Non-zero value if c is a particular representation of
* a decimal-digit character.
*/
PJ_INLINE(int) pj_isdigit(unsigned char c) { return isdigit(c); }
/**
* Returns a non-zero value if c is a particular representation of
* a space character (0x09 - 0x0D or 0x20).
* @param c The integer character to test.
* @return Non-zero value if c is a particular representation of
* a space character (0x09 - 0x0D or 0x20).
*/
PJ_INLINE(int) pj_isspace(unsigned char c) { return isspace(c); }
/**
* Returns a non-zero value if c is a particular representation of
* a lowercase character.
* @param c The integer character to test.
* @return Non-zero value if c is a particular representation of
* a lowercase character.
*/
PJ_INLINE(int) pj_islower(unsigned char c) { return islower(c); }
/**
* Returns a non-zero value if c is a particular representation of
* a uppercase character.
* @param c The integer character to test.
* @return Non-zero value if c is a particular representation of
* a uppercase character.
*/
PJ_INLINE(int) pj_isupper(unsigned char c) { return isupper(c); }
/**
* Returns a non-zero value if c is a either a space (' ') or horizontal
* tab ('\\t') character.
* @param c The integer character to test.
* @return Non-zero value if c is a either a space (' ') or horizontal
* tab ('\\t') character.
*/
PJ_INLINE(int) pj_isblank(unsigned char c) { return (c==' ' || c=='\t'); }
/**
* Converts character to lowercase.
* @param c The integer character to convert.
* @return Lowercase character of c.
*/
PJ_INLINE(int) pj_tolower(unsigned char c) { return tolower(c); }
/**
* Converts character to uppercase.
* @param c The integer character to convert.
* @return Uppercase character of c.
*/
PJ_INLINE(int) pj_toupper(unsigned char c) { return toupper(c); }
/**
* Returns a non-zero value if c is a particular representation of
* an hexadecimal digit character.
* @param c The integer character to test.
* @return Non-zero value if c is a particular representation of
* an hexadecimal digit character.
*/
PJ_INLINE(int) pj_isxdigit(unsigned char c){ return isxdigit(c); }
/**
* Array of hex digits, in lowerspace.
*/
/*extern char pj_hex_digits[];*/
#define pj_hex_digits "0123456789abcdef"
/**
* Convert a value to hex representation.
* @param value Integral value to convert.
* @param p Buffer to hold the hex representation, which must be
* at least two bytes length.
*/
PJ_INLINE(void) pj_val_to_hex_digit(unsigned value, char *p)
{
*p++ = pj_hex_digits[ (value & 0xF0) >> 4 ];
*p = pj_hex_digits[ (value & 0x0F) ];
}
/**
* Convert hex digit c to integral value.
* @param c The hex digit character.
* @return The integral value between 0 and 15.
*/
PJ_INLINE(unsigned) pj_hex_digit_to_val(unsigned char c)
{
if (c <= '9')
return (c-'0') & 0x0F;
else if (c <= 'F')
return (c-'A'+10) & 0x0F;
else
return (c-'a'+10) & 0x0F;
}
/** @} */
PJ_END_DECL
#endif /* __PJ_CTYPE_H__ */

995
GSMGateway/app/src/main/cpp/pj/doxygen.h Normal file
View File

@@ -0,0 +1,995 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_DOXYGEN_H__
#define __PJ_DOXYGEN_H__
/**
* @file doxygen.h
* @brief Doxygen's mainpage.
*/
/*////////////////////////////////////////////////////////////////////////// */
/*
INTRODUCTION PAGE
*/
/**
* @mainpage Welcome to PJLIB!
*
* @section intro_sec What is PJLIB
*
* PJLIB is an Open Source, small footprint framework library written in C for
* making scalable applications. Because of its small footprint, it can be used
* in embedded applications (we hope so!), but yet the library is also aimed for
* facilitating the creation of high performance protocol stacks.
*
* PJLIB is released under GPL terms.
*
* @section download_sec Download
*
* PJLIB and all documentation can be downloaded from
* http://www.pjsip.org.
*
*
* @section how_to_use_sec About This Documentation
*
* This document is generated directly from PJLIB source file using
* \a doxygen (http://www.doxygen.org). Doxygen is a great (and free!)
* tools for generating such documentation.
*
*
* @subsection find_samples_subsec How to Read This Document
*
* This documentation is laid out more to be a reference guide instead
* of tutorial, therefore first time users may find it difficult to
* grasp PJLIB by reading this document alone.
*
* However, we've tried our best to make this document easy to follow.
* For first time users, we would suggest that you follow these steps
* when reading this documentation:
*
* - continue reading this introduction chapter. At the end of this
* chapter, you'll find section called \ref pjlib_fundamentals_sec
* which should guide you to understand basic things about PJLIB.
*
* - find information about specific features that you want to use
* in PJLIB. Use the <b>Module Index</b> to find out about all
* features in PJLIB (if you're browsing the HTML documentation,
* click on the \a Module link on top of the page, or if you're
* reading the PDF documentation, click on \a Module \a Documentation
* on the navigation pane on the left).
*
* @subsection doc_organize_sec How To's
*
* Please find below links to specific tasks that you probably
* want to do:
*
* - <b>How to Build PJLIB</b>
*\n
* Please refer to \ref pjlib_build_sys_pg page for more information.
*
* - <b>How to Use PJLIB in My Application</b>
*\n
* Please refer to \ref configure_app_sec for more information.
*
* - <b>How to Port PJLIB</b>
*\n
* Please refer to \ref porting_pjlib_pg page.
*
* - <b>Where to Read Samples Documentation</b>
*\n
* Most of the modules provide link to the corresponding sample file.
* Alternatively, to get the list of all examples, you can click on
* <b>Related Pages</b> on the top of HTML document or on
* <b>PJLIB Page Documentation</b> on navigation pane of your PDF reader.
*
* - <b>How to Submit Code to PJLIB Project</b>
*\n
* Please read \ref pjlib_coding_convention_page before submitting
* your code. Send your code as patch against current Subversion tree
* to the appropriate mailing list.
*
*
* @section features_sec Features
*
* @subsection open_source_feat It's Open Source!
*
* PJLIB is currently released on GPL license, but other arrangements
* can be made with the author.
*
* @subsection extreme_portable_feat Extreme Portability
*
* PJLIB is designed to be extremely portable. It can run on any kind
* of processors (16-bit, 32-bit, or 64-bit, big or little endian, single
* or multi-processors) and operating systems. Floating point or no
* floating point. Multi-threading or not.
* It can even run in environment where no ANSI LIBC is available.
*
* Currently PJLIB is known to run on these platforms:
* - Win32/x86 (Win95/98/ME, NT/2000/XP/2003, mingw).
* - arm, WinCE and Windows Mobile.
* - Linux/x86, (user mode and as <b>kernel module</b>(!)).
* - Linux/alpha
* - Solaris/ultra.
* - MacOS X/powerpc
* - RTEMS (x86 and powerpc).
*
* And efforts is under way to port PJLIB on:
* - Symbian OS
*
*
* @subsection small_size_feat Small in Size
*
* One of the primary objectives is to have library that is small in size for
* typical embedded applications. As a rough guidance, we aim to keep the
* library size below 100KB for it to be considered as small.
* As the result, most of the functionalities in the library can be tailored
* to meet the requirements; user can enable/disable specific functionalities
* to get the desired size/performance/functionality balance.
*
* For more info, please see @ref pj_config.
*
*
* @subsection big_perform_feat Big in Performance
*
* Almost everything in PJLIB is designed to achieve the highest possible
* performance out of the target platform.
*
*
* @subsection no_dyn_mem No Dynamic Memory Allocations
*
* The central idea of PJLIB is that for applications to run as fast as it can,
* it should not use \a malloc() at all, but instead should get the memory
* from a preallocated storage pool. There are few things that can be
* optimized with this approach:
*
* - \a alloc() is a O(1) operation.
* - no mutex is used inside alloc(). It is assumed that synchronization
* will be used in higher abstraction by application anyway.
* - no \a free() is required. All chunks will be deleted when the pool is
* destroyed.
*
* The performance gained on some systems can be as high as 30x speed up
* against \a malloc() and \a free() on certain configurations, but of
* course your mileage may vary.
*
* For more information, see \ref PJ_POOL_GROUP
*
*
* @subsection os_abstract_feat Operating System Abstraction
*
* PJLIB has abstractions for features that are normally not portable
* across operating systems:
* - @ref PJ_THREAD
*\n
* Portable thread manipulation.
* - @ref PJ_TLS
*\n
* Storing data in thread's private data.
* - @ref PJ_MUTEX
*\n
* Mutual exclusion protection.
* - @ref PJ_SEM
*\n
* Semaphores.
* - @ref PJ_ATOMIC
*\n
* Atomic variables and their operations.
* - @ref PJ_CRIT_SEC
*\n
* Fast locking of critical sections.
* - @ref PJ_LOCK
*\n
* High level abstraction for lock objects.
* - @ref PJ_EVENT
*\n
* Event object.
* - @ref PJ_TIME
*\n
* Portable time manipulation.
* - @ref PJ_TIMESTAMP
*\n
* High resolution time value.
* - etc.
*
*
* @subsection ll_network_io_sec Low-Level Network I/O
*
* PJLIB has very portable abstraction and fairly complete set of API for
* doing network I/O communications. At the lowest level, PJLIB provides:
*
* - @ref PJ_SOCK
*\n
* A highly portable socket abstraction, runs on all kind of
* network APIs such as standard BSD socket, Windows socket, Linux
* \b kernel socket, PalmOS networking API, etc.
*
* - @ref pj_addr_resolve
*\n
* Portable address resolution, which implements #pj_gethostbyname().
*
* - @ref PJ_SOCK_SELECT
*\n
* A portable \a select() like API (#pj_sock_select()) which can be
* implemented with various back-end.
*
*
*
* @subsection timer_mgmt_sec Timer Management
*
* A passive framework for managing timer, see @ref PJ_TIMER for more info.
* There is also function to retrieve high resolution timestamp
* from the system (see @ref PJ_TIMESTAMP).
*
*
* @subsection data_struct_sec Various Data Structures
*
* Various data structures are provided in the library:
*
* - @ref PJ_PSTR
* - @ref PJ_ARRAY
* - @ref PJ_HASH
* - @ref PJ_LIST
* - @ref PJ_RBTREE
*
*
* @subsection exception_sec Exception Construct
*
* A convenient TRY/CATCH like construct to propagate errors, which by
* default are used by the @ref PJ_POOL_GROUP "memory pool" and
* the lexical scanner in pjlib-util. The exception
* construct can be used to write programs like below:
*
* <pre>
* #define SYNTAX_ERROR 1
*
* PJ_TRY {
* msg = NULL;
* msg = parse_msg(buf, len);
* }
* PJ_CATCH ( SYNTAX_ERROR ) {
* .. handle error ..
* }
* PJ_END;
* </pre>
*
* Please see @ref PJ_EXCEPT for more information.
*
*
* @subsection logging_sec Logging Facility
*
* PJLIB @ref PJ_LOG consists of macros to write logging information to
* some output device. Some of the features of the logging facility:
*
* - the verbosity can be fine-tuned both at compile time (to control
* the library size) or run-time (to control the verbosity of the
* information).
* - output device is configurable (e.g. stdout, printk, file, etc.)
* - log decoration is configurable.
*
* See @ref PJ_LOG for more information.
*
*
* @subsection guid_gen_sec Random and GUID Generation
*
* PJLIB provides facility to create random string
* (#pj_create_random_string()) or globally unique identifier
* (see @ref PJ_GUID).
*
*
*
* @section configure_app_sec Configuring Application to use PJLIB
*
* @subsection pjlib_compil_sec Building PJLIB
*
* Follow the instructions in \ref pjlib_build_sys_pg to build
* PJLIB.
*
* @subsection pjlib_compil_app_sec Building Applications with PJLIB
*
* Use the following settings when building applications with PJLIB.
*
* @subsubsection compil_inc_dir_sec Include Search Path
*
* Add this to your include search path ($PJLIB is PJLIB root directory):
* <pre>
* $PJLIB/include
* </pre>
*
* @subsubsection compil_inc_file_sec Include PJLIB Header
*
* To include all PJLIB headers:
* \verbatim
#include <pjlib.h>
\endverbatim
*
* Alternatively, you can include individual PJLIB headers like this:
* \verbatim
#include <pj/log.h>
#include <pj/os.h>
\endverbatim
*
*
* @subsubsection compil_lib_dir_sec Library Path
*
* Add this to your library search path:
* <pre>
* $PJLIB/lib
* </pre>
*
* Then add the appropriate PJLIB library to your link specification. For
* example, you would add \c libpj-i386-linux-gcc.a when you're building
* applications in Linux.
*
*
* @subsection pjlib_fundamentals_sec Principles in Using PJLIB
*
* Few things that you \b MUST do when using PJLIB, to make sure that
* you create trully portable applications.
*
* @subsubsection call_pjlib_init_sec Call pj_init()
*
* Before you do anything else, call \c pj_init(). This would make sure that
* PJLIB system is properly set up.
*
* @subsubsection no_ansi_subsec Do NOT Use ANSI C
*
* Contrary to popular teaching, ANSI C (and LIBC) is not the most portable
* library in the world, nor it's the most ubiquitous. For example, LIBC
* is not available in Linux kernel. Also normally LIBC will be excluded
* from compilation of RTOSes to reduce size.
*
* So for maximum portability, do NOT use ANSI C. Do not even try to include
* any other header files outside <include/pj>. Stick with the functionalities
* provided by PJLIB.
*
*
* @subsubsection string_rep_subsubsec Use pj_str_t instead of C Strings
*
* PJLIB uses pj_str_t instead of normal C strings. You SHOULD follow this
* convention too. Remember, ANSI string-h is not always available. And
* PJLIB string is faster!
*
* @subsubsection mem_alloc_subsubsec Use Pool for Memory Allocations
*
* You MUST NOT use \a malloc() or any other memory allocation functions.
* Use PJLIB @ref PJ_POOL_GROUP instead! It's faster and most portable.
*
* @subsection logging_subsubsec Use Logging for Text Display
*
* DO NOT use <stdio.h> for text output. Use PJLIB @ref PJ_LOG instead.
*
*
* @section porting_pjlib_sec0 Porting PJLIB
*
* Please see \ref porting_pjlib_pg page on more information to port
* PJLIB to new target.
*
* @section enjoy_sec Enjoy Using PJLIB!
*
* We hope that you find PJLIB usefull for your application. If you
* have any questions, suggestions, critics, bug fixes, or anything
* else, we would be happy to hear it.
*
* Enjoy using PJLIB!
*
* Benny Prijono < bennylp at pjsip dot org >
*/
/*////////////////////////////////////////////////////////////////////////// */
/*
CODING CONVENTION
*/
/**
* @page pjlib_coding_convention_page Coding Convention
*
* Before you submit your code/patches to be included with PJLIB, you must
* make sure that your code is compliant with PJLIB coding convention.
* <b>This is very important!</b> Otherwise we would not accept your code.
*
* @section coding_conv_editor_sec Editor Settings
*
* The single most important thing in the whole coding convention is editor
* settings. It's more important than the correctness of your code (bugs will
* only crash the system, but incorrect tab size is mental!).
*
* Kindly set your editor as follows:
* - tab size to \b 8.
* - indentation to \b 4.
*
* With \c vi, you can do it with:
* <pre>
* :se ts=8
* :se sts=4
* </pre>
*
* You should replace tab with eight spaces.
*
* @section coding_conv_detail_sec Coding Style
*
* Coding style MUST strictly follow K&R style. The rest of coding style
* must follow current style. You SHOULD be able to observe the style
* currently used by PJLIB from PJLIB sources, and apply the style to your
* code. If you're not able to do simple thing like to observe PJLIB
* coding style from the sources, then logic dictates that your ability to
* observe more difficult area in PJLIB such as memory allocation strategy,
* concurrency, etc is questionable.
*
* @section coding_conv_comment_sec Commenting Your Code
*
* Public API (e.g. in header files) MUST have doxygen compliant comments.
*
*/
/*////////////////////////////////////////////////////////////////////////// */
/*
BUILDING AND INSTALLING PJLIB
*/
/**
* @page pjlib_build_sys_pg Building, and Installing PJLIB
*
* @section build_sys_install_sec Build and Installation
*
* \note
* <b>The most up-to-date information on building and installing PJLIB
* should be found in the website, under "Getting Started" document.
* More over, the new PJLIB build system is now based on autoconf,
* so some of the information here might not be relevant anymore
* (although most still are, since the autoconf script still use
* the old Makefile system as the backend).</b>
*
* @subsection build_sys_install_win32_sec Visual Studio
*
* The PJLIB Visual Studio workspace supports the building of PJLIB
* for Win32 target. Although currently only the Visual Studio 6 Workspace is
* actively maintained, developers with later version of Visual Studio
* can easily imports VS6 workspace into their IDE.
*
* To start building PJLIB projects with Visual Studio 6 or later, open
* the \a workspace file in the corresponding \b \c build directory. You have
* several choices on which \a dsw file to open:
\verbatim
$PJPROJECT/pjlib/build/pjlib.dsw
$PJPROJECT/pjsip/build/pjsip.dsw
..etc
\endverbatim
*
* The easiest way is to open <tt>pjsip_apps.dsw</tt> file in \b \c $PJPROJECT/pjsip-apps/build
* directory, and build pjsua project or the samples project.
* However this will not build the complete projects.
* For example, the PJLIB test is not included in this workspace.
* To build the complete projects, you must
* open and build each \a dsw file in \c build directory in each
* subprojects. For example, to open the complete PJLIB workspace, open
* <tt>pjlib.dsw</tt> in <tt>$PJPROJECT/pjlib/build</tt> directory.
*
*
* @subsubsection config_site_create_vc_sec Create config_site.h
*
* The file <tt><b>$PJPROJECT/pjlib/include/pj/config_site.h</b></tt>
* is supposed to contain configuration that is specific to your site/target.
* This file is not part of PJLIB, so you must create it yourself. Normally
* you just need to create a blank file.
*
* The reason why it's not included in PJLIB is so that you would not accidently
* overwrite your site configuration.
*
* If you fail to do this, Visual C will complain with error like:
*
* <b>"fatal error C1083: Cannot open include file: 'pj/config_site.h': No such file
* or directory"</b>.
*
* @subsubsection build_vc_subsubsec Build the Projects
*
* Just hit the build button!
*
*
* @subsection build_sys_install_unix_sec Make System
*
* For other targets, PJLIB provides a rather comprehensive build system
* that uses GNU \a make (and only GNU \a make will work).
* Currently, the build system supports building * PJLIB for these targets:
* - i386/Win32/mingw
* - i386/Linux
* - i386/Linux (kernel)
* - alpha/linux
* - sparc/SunOS
* - etc..
*
*
* @subsubsection build_req_sec Requirements
*
* In order to use the \c make based build system, you MUST have:
*
* - <b>GNU make</b>
*\n
* The Makefiles heavily utilize GNU make commands which most likely
* are not available in other \c make system.
* - <b>bash</b> shell is recommended.
*\n
* Specificly, there is a command <tt>"echo -n"</tt> which may not work
* in other shells. This command is used when generating dependencies
* (<tt>make dep</tt>) and it's located in
* <tt>$PJPROJECT/build/rules.mak</tt>.
* - <b>ar</b>, <b>ranlib</b> from GNU binutils
*\n
* In your system has different <tt>ar</tt> or <tt>ranlib</tt> (e.g. they
* may have been installed as <tt>gar</tt> and <tt>granlib</tt>), then
* either you create the relevant symbolic links, <b>or</b> modify
* <tt>$PJPROJECT/build/cc-gcc.mak</tt> and rename <tt>ar</tt> and
* <tt>ranlib</tt> to the appropriate names.
* - <b>gcc</b> to generate dependency.
*\n
* Currently the build system uses <tt>"gcc -MM"</tt> to generate build
* dependencies. If <tt>gcc</tt> is not desired to generate dependency,
* then either you don't run <tt>make dep</tt>, <b>or</b> edit
* <tt>$PJPROJECT/build/rules.mak</tt> to calculate dependency using
* your prefered method. (And let me know when you do so so that I can
* update the file. :) )
*
* @subsubsection build_overview_sec Building the Project
*
* Generally, steps required to build the PJLIB are:
*
\verbatim
$ cd /home/user/pjproject
$ ./configure
$ touch pjlib/include/pj/config_site.h
$ make dep
$ make
\endverbatim
*
* The above process will build all static libraries and all applications.
*
* \note the <tt>configure</tt> script is not a proper autoconf script,
* but rather a simple shell script to detect current host. This script
* currently does not support cross-compilation.
*
* \note For Linux kernel target, there are additional steps required, which
* will be explained in section \ref linux_kern_target_subsec.
*
* @subsubsection build_mak_sec Cross Compilation
*
* For cross compilation, you will need to edit the \c build.mak file in
* \c $PJPROJECT root directory manually. Please see <b>README-configure</b> file
* in the root directory for more information.
*
* For Linux kernel target, you are also required to declare the following
* variables in this file:
* - \c KERNEL_DIR: full path of kernel source tree.
* - \c KERNEL_ARCH: kernel ARCH options (e.g. "ARCH=um"), or leave blank
* for default.
* - \c PJPROJECT_DIR: full path of PJPROJECT source tree.
*
* Apart from these, there are also additional steps required to build
* Linux kernel target, which will be explained in \ref linux_kern_target_subsec.
*
* @subsubsection build_dir_sec Files in "build" Directory
*
* The <tt>*.mak</tt> files in \c $PJPROJECT/build directory are used to specify
* the configuration for the specified compiler, target machine target
* operating system, and host options. These files will be executed
* (included) by \a make during building process, depending on the values
* specified in <b>$PJPROJECT/build.mak</b> file.
*
* Normally you don't need to edit these files, except when you're porting
* PJLIB to new target.
*
* Below are the description of some files in this directory:
*
* - <tt>rules.mak</tt>: contains generic rules always included during make.
* - <tt>cc-gcc.mak</tt>: rules when gcc is used for compiler.
* - <tt>cc-vc.mak</tt>: rules when MSVC compiler is used.
* - <tt>host-mingw.mak</tt>: rules for building in mingw host.
* - <tt>host-unix.mak</tt>: rules for building in Unix/Posix host.
* - <tt>host-win32.mak</tt>: rules for building in Win32 command console
* (only valid when VC is used).
* - <tt>m-i386.mak</tt>: rules when target machine is an i386 processor.
* - <tt>m-m68k.mak</tt>: rules when target machine is an m68k processor.
* - <tt>os-linux.mak</tt>: rules when target OS is Linux.
* - <tt>os-linux-kernel.mak</tt>: rules when PJLIB is to be build as
* part of Linux kernel.
* - <tt>os-win32.mak</tt>: rules when target OS is Win32.
*
*
* @subsubsection config_site_create_sec Create config_site.h
*
* The file <tt><b>$PJPROJECT/pjlib/include/pj/config_site.h</b></tt>
* is supposed to contain configuration that is specific to your site/target.
* This file is not part of PJLIB, so you must create it yourself.
*
* The reason why it's not included in PJLIB is so that you would not accidently
* overwrite your site configuration.
*
*
* @subsubsection invoking_make_sec Invoking make
*
* Normally, \a make is invoked in \c build directory under each project.
* For example, to build PJLIB, you would invoke \a make in
* \c $PJPROJECT/pjlib/build directory like below:
*
\verbatim
$ cd pjlib/build
$ make
\endverbatim
*
* Alternatively you may invoke <tt>make</tt> in <tt>$PJPROJECT</tt>
* directory, to build all projects under that directory (e.g.
* PJLIB, PJSIP, etc.).
*
*
* @subsubsection linux_kern_target_subsec Linux Kernel Target
*
* \note
* <b>BUILDING APPLICATIONS IN LINUX KERNEL MODE IS A VERY DANGEROUS BUSINESS.
* YOU MAY CRASH THE WHOLE OF YOUR SYSTEM, CORRUPT YOUR HARDISK, ETC. PJLIB
* KERNEL MODULES ARE STILL IN EXPERIMENTAL PHASE. DO NOT RUN IT IN PRODUCTION
* SYSTEMS OR OTHER SYSTEMS WHERE RISK OF LOSS OF DATA IS NOT ACCEPTABLE.
* YOU HAVE BEEN WARNED.</b>
*
* \note
* <b>User Mode Linux (UML)</b> provides excellent way to experiment with Linux
* kernel without risking the stability of the host system. See
* http://user-mode-linux.sourceforge.net for details.
*
* \note
* I only use <b>UML</b> to experiment with PJLIB kernel modules.
* <b>I wouldn't be so foolish to use my host Linux machine to experiment
* with this.</b>
*
* \note
* You have been warned.
*
* For building PJLIB for Linux kernel target, there are additional steps required.
* In general, the additional tasks are:
* - Declare some more variables in <b><tt>build.mak</tt></b> file (this
* has been explained in \ref build_mak_sec above).
* - Perform these two small modifications in kernel source tree.
*
* There are two small modification need to be applied to the kernel tree.
*
* <b>1. Edit <tt>Makefile</tt> in kernel root source tree.</b>
*
* Add the following lines at the end of the <tt>Makefile</tt> in your
* <tt>$KERNEL_SRC</tt> dir:
\verbatim
script:
$(SCRIPT)
\endverbatim
*
* \note Remember to replace spaces with <b>tab</b> in the Makefile.
*
* The modification above is needed to capture kernel's \c $CFLAGS and
* \c $CFLAGS_MODULE which will be used for PJLIB's compilation.
*
* <b>2. Add Additional Exports.</b>
*
* We need the kernel to export some more symbols for our use. So we declare
* the additional symbols to be exported in <tt>extra-exports.c</tt> file, and add
* a this file to be compiled into the kernel:
*
* - Copy the file <tt>extra-exports.c</tt> from <tt>pjlib/src/pj</tt>
* directory to <tt>$KERNEL_SRC/kernel/</tt> directory.
* - Edit <tt>Makefile</tt> in that directory, and add this line
* somewhere after the declaration of that variable:
\verbatim
obj-y += extra-exports.o
\endverbatim
*
* To illustrate what have been done in your kernel source tree, below
* is screenshot of my kernel source tree _after_ the modification.
*
\verbatim
[root@vpc-linux linux-2.6.7]# pwd
/usr/src/linux-2.6.7
[root@vpc-linux linux-2.6.7]#
[root@vpc-linux linux-2.6.7]#
[root@vpc-linux linux-2.6.7]# tail Makefile
endif # skip-makefile
FORCE:
.PHONY: script
script:
$(SCRIPT)
[root@vpc-linux linux-2.6.7]#
[root@vpc-linux linux-2.6.7]#
[root@vpc-linux linux-2.6.7]# head kernel/extra-exports.c
#include <linux/module.h>
#include <linux/syscalls.h>
EXPORT_SYMBOL(sys_select);
EXPORT_SYMBOL(sys_epoll_create);
EXPORT_SYMBOL(sys_epoll_ctl);
EXPORT_SYMBOL(sys_epoll_wait);
EXPORT_SYMBOL(sys_socket);
[root@vpc-linux linux-2.6.7]#
[root@vpc-linux linux-2.6.7]#
[root@vpc-linux linux-2.6.7]# head -15 kernel/Makefile
#
# Makefile for the linux kernel.
#
obj-y = sched.o fork.o exec_domain.o panic.o printk.o profile.o \
exit.o itimer.o time.o softirq.o resource.o \
sysctl.o capability.o ptrace.o timer.o user.o \
signal.o sys.o kmod.o workqueue.o pid.o \
rcupdate.o intermodule.o extable.o params.o posix-timers.o \
kthread.o
obj-y += extra-exports.o
obj-$(CONFIG_FUTEX) += futex.o
obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o
[root@vpc-linux linux-2.6.7]#
\endverbatim
*
* Then you must rebuild the kernel.
* If you fail to do this, you won't be able to <b>insmod</b> pjlib.
*
* \note You will see a lots of warning messages during pjlib-test compilation.
* The warning messages complain about unresolved symbols which are defined
* in pjlib module. You can safely ignore these warnings. However, you can not
* ignore warnings about non-pjlib unresolved symbols.
*
*
* @subsection makefile_explained_sec Makefile Explained
*
* The \a Makefile for each project (e.g. PJLIB, PJSIP, etc) should be
* very similar in the contents. The Makefile is located under \c build
* directory in each project subdir.
*
* @subsubsection pjlib_makefile_subsec PJLIB Makefile.
*
* Below is PJLIB's Makefile:
*
* \include build/Makefile
*
* @subsubsection pjlib_os_makefile_subsec PJLIB os-linux.mak.
*
* Below is file <tt><b>os-linux.mak</b></tt> file in
* <tt>$PJPROJECT/pjlib/build</tt> directory,
* which is OS specific configuration file for Linux target that is specific
* for PJLIB project. For \b global OS specific configuration, please see
* <tt>$PJPROJECT/build/os-*.mak</tt>.
*
* \include build/os-linux.mak
*
*/
/*////////////////////////////////////////////////////////////////////////// */
/*
PORTING PJLIB
*/
/**
* @page porting_pjlib_pg Porting PJLIB
*
* \note
* <b>Since version 0.5.8, PJLIB build system is now based on autoconf, so
* most of the time we shouldn't need to apply the tweakings below to get
* PJLIB working on a new platform. However, since the autoconf build system
* still uses the old Makefile build system, the information below may still
* be useful for reference.
* </b>
*
* @section new_arch_sec Porting to New CPU Architecture
*
* Below is step-by-step guide to add support for new CPU architecture.
* This sample is based on porting to Alpha architecture; however steps for
* porting to other CPU architectures should be pretty similar.
*
* Also note that in this example, the operating system used is <b>Linux</b>.
* Should you wish to add support for new operating system, then follow
* the next section \ref porting_os_sec.
*
* Step-by-step guide to port to new CPU architecture:
* - decide the name for the new architecture. In this case, we choose
* <tt><b>alpha</b></tt>.
* - edit file <tt>$PJPROJECT/build.mak</tt>, and add new section for
* the new target:
* <pre>
* #
* # Linux alpha, gcc
* #
* export MACHINE_NAME := <b>alpha</b>
* export OS_NAME := linux
* export CC_NAME := gcc
* export HOST_NAME := unix
* </pre>
*
* - create a new file <tt>$PJPROJECT/build/<b>m-alpha</b>.mak</tt>.
* Alternatively create a copy from other file in this directory.
* The contents of this file will look something like:
* <pre>
* export M_CFLAGS := $(CC_DEF)<b>PJ_M_ALPHA=1</b>
* export M_CXXFLAGS :=
* export M_LDFLAGS :=
* export M_SOURCES :=
* </pre>
* - create a new file <tt>$PJPROJECT/pjlib/include/pj/compat/<b>m_alpha.h</b></tt>.
* Alternatively create a copy from other header file in this directory.
* The contents of this file will look something like:
* <pre>
* #define PJ_HAS_PENTIUM 0
* #define PJ_IS_LITTLE_ENDIAN 1
* #define PJ_IS_BIG_ENDIAN 0
* </pre>
* - edit <tt>pjlib/include/pj/<b>config.h</b></tt>. Add new processor
* configuration in this header file, like follows:
* <pre>
* ...
* #elif defined (PJ_M_ALPHA) && PJ_M_ALPHA != 0
* # include <pj/compat/m_alpha.h>
* ...
* </pre>
* - done. Build PJLIB with:
* <pre>
* $ cd $PJPROJECT/pjlib/build
* $ make dep
* $ make clean
* $ make
* </pre>
*
* @section porting_os_sec Porting to New Operating System Target
*
* This section will try to give you rough guideline on how to
* port PJLIB to a new target. As a sample, we give the target a name tag,
* for example <tt><b>xos</b></tt> (for X OS).
*
* @subsection new_compat_os_h_file_sec Create New Compat Header File
*
* You'll need to create a new header file
* <b><tt>include/pj/compat/os_xos.h</tt></b>. You can copy as a
* template other header file and edit it accordingly.
*
* @subsection modify_config_h_file_sec Modify config.h
*
* Then modify file <b><tt>include/pj/config.h</tt></b> to include
* this file accordingly (e.g. when macro <tt><b>PJ_XOS</b></tt> is
* defined):
*
\verbatim
...
#elif defined(PJ_XOS)
# include <pj/compat/os_xos.h>
#else
#...
\endverbatim
*
* @subsection new_target_mak_file_sec Create New Global Make Config File
*
* Then you'll need to create global configuration file that
* is specific for this OS, i.e. <tt><b>os-xos.mak</b></tt> in
* <tt><b>$PJPROJECT/build</b></tt> directory.
*
* At very minimum, the file will normally need to define
* <tt><b>PJ_XOS=1</b></tt> in the \c CFLAGS section:
*
\verbatim
#
# $PJPROJECT/build/os-xos.mak:
#
export OS_CFLAGS := $(CC_DEF)PJ_XOS=1
export OS_CXXFLAGS :=
export OS_LDFLAGS :=
export OS_SOURCES :=
\endverbatim
*
*
* @subsection new_target_prj_mak_file_sec Create New Project's Make Config File
*
* Then you'll need to create xos-specific configuration file
* for PJLIB. This file is also named <tt><b>os-xos.mak</b></tt>,
* but its located in <tt><b>pjlib/build</b></tt> directory.
* This file will specify source files that are specific to
* this OS to be included in the build process.
*
* Below is a sample:
\verbatim
#
# pjlib/build/os-xos.mak:
# XOS specific configuration for PJLIB.
#
export PJLIB_OBJS += os_core_xos.o \
os_error_unix.o \
os_time_ansi.o
export TEST_OBJS += main.o
export TARGETS = pjlib pjlib-test
\endverbatim
*
* @subsection new_target_src_sec Create and Edit Source Files
*
* You'll normally need to create at least these files:
* - <tt><b>os_core_xos.c</b></tt>: core OS specific
* functionality.
* - <tt><b>os_timestamp_xos.c</b></tt>: how to get timestamp
* in this OS.
*
* Depending on how things are done in your OS, you may need
* to create these files:
* - <tt><b>os_error_*.c</b></tt>: how to manipulate
* OS error codes. Alternatively you may use existing
* <tt>os_error_unix.c</tt> if the OS has \c errno and
* \c strerror() function.
* - <tt><b>ioqueue_*.c</b></tt>: if the OS has specific method
* to perform asynchronous I/O. Alternatively you may
* use existing <tt>ioqueue_select.c</tt> if the OS supports
* \c select() function call.
* - <tt><b>sock_*.c</b></tt>: if the OS has specific method
* to perform socket communication. Alternatively you may
* use existing <tt>sock_bsd.c</tt> if the OS supports
* BSD socket API, and edit <tt>include/pj/compat/socket.h</tt>
* file accordingly.
*
* You will also need to check various files in
* <tt><b>include/pj/compat/xxx.h</b></tt>, to see if they're
* compatible with your OS.
*
* @subsection new_target_build_file_sec Build The Project
*
* After basic building blocks have been created for the OS, then
* the easiest way to see which parts need to be fixed is by building
* the project and see the error messages.
*
* @subsection new_target_edit_vs_new_file_sec Editing Existing Files vs Creating New File
*
* When you encounter compatibility errors in PJLIB during porting,
* you have three options on how to fix the error:
* - edit the existing <tt>*.c</tt> file, and give it <tt>#ifdef</tt>
* switch for the new OS, or
* - edit <tt>include/pj/compat/*.h</tt> instead, or
* - create a totally new file.
*
* Basicly there is no strict rule on which approach is the best
* to use, however the following guidelines may be used:
* - if the file is expected to be completely different than
* any existing file, then perhaps you should create a completely
* new file. For example, file <tt>os_core_xxx.c</tt> will
* normally be different for each OS flavour.
* - if the difference can be localized in <tt>include/compat</tt>
* header file, and existing <tt>#ifdef</tt> switch is there,
* then preferably you should edit this <tt>include/compat</tt>
* header file.
* - if the existing <tt>*.c</tt> file has <tt>#ifdef</tt> switch,
* then you may add another <tt>#elif</tt> switch there. This
* normally is used for behaviors that are not totally
* different on each platform.
* - other than that above, use your own judgement on whether
* to edit the file or create new file etc.
*/
#endif /* __PJ_DOXYGEN_H__ */

593
GSMGateway/app/src/main/cpp/pj/errno.h Normal file
View File

@@ -0,0 +1,593 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_ERRNO_H__
#define __PJ_ERRNO_H__
/**
* @file errno.h
* @brief PJLIB Error Subsystem
*/
#include <pj/types.h>
#include <pj/compat/errno.h>
#include <stdarg.h>
PJ_BEGIN_DECL
/**
* @defgroup pj_errno Error Subsystem
* @{
*
* The PJLIB Error Subsystem is a framework to unify all error codes
* produced by all components into a single error space, and provide
* uniform set of APIs to access them. With this framework, any error
* codes are encoded as pj_status_t value. The framework is extensible,
* application may register new error spaces to be recognized by
* the framework.
*
* @section pj_errno_retval Return Values
*
* All functions that returns @a pj_status_t returns @a PJ_SUCCESS if the
* operation was completed successfully, or non-zero value to indicate
* error. If the error came from operating system, then the native error
* code is translated/folded into PJLIB's error namespace by using
* #PJ_STATUS_FROM_OS() macro. The function will do this automatically
* before returning the error to caller.
*
* @section err_services Retrieving and Displaying Error Messages
*
* The framework provides the following APIs to retrieve and/or display
* error messages:
*
* - #pj_strerror(): this is the base API to retrieve error string
* description for the specified pj_status_t error code.
*
* - #PJ_PERROR() macro: use this macro similar to PJ_LOG to format
* an error message and display them to the log
*
* - #pj_perror(): this function is similar to PJ_PERROR() but unlike
* #PJ_PERROR(), this function will always be included in the
* link process. Due to this reason, prefer to use #PJ_PERROR()
* if the application is concerned about the executable size.
*
* Application MUST NOT pass native error codes (such as error code from
* functions like GetLastError() or errno) to PJLIB functions expecting
* @a pj_status_t.
*
* @section err_extending Extending the Error Space
*
* Application may register new error space to be recognized by the
* framework by using #pj_register_strerror(). Use the range started
* from PJ_ERRNO_START_USER to avoid conflict with existing error
* spaces.
*
*/
/**
* Guidelines on error message length.
*/
#define PJ_ERR_MSG_SIZE 80
/**
* Buffer for title string of #PJ_PERROR().
*/
#ifndef PJ_PERROR_TITLE_BUF_SIZE
# define PJ_PERROR_TITLE_BUF_SIZE 120
#endif
/**
* Get the last platform error/status, folded into pj_status_t.
* @return OS dependent error code, folded into pj_status_t.
* @remark This function gets errno, or calls GetLastError() function and
* convert the code into pj_status_t with PJ_STATUS_FROM_OS. Do
* not call this for socket functions!
* @see pj_get_netos_error()
*/
PJ_DECL(pj_status_t) pj_get_os_error(void);
/**
* Set last error.
* @param code pj_status_t
*/
PJ_DECL(void) pj_set_os_error(pj_status_t code);
/**
* Get the last error from socket operations.
* @return Last socket error, folded into pj_status_t.
*/
PJ_DECL(pj_status_t) pj_get_netos_error(void);
/**
* Set error code.
* @param code pj_status_t.
*/
PJ_DECL(void) pj_set_netos_error(pj_status_t code);
/**
* Get the error message for the specified error code. The message
* string will be NULL terminated.
*
* @param statcode The error code.
* @param buf Buffer to hold the error message string.
* @param bufsize Size of the buffer.
*
* @return The error message as NULL terminated string,
* wrapped with pj_str_t.
*/
PJ_DECL(pj_str_t) pj_strerror( pj_status_t statcode,
char *buf, pj_size_t bufsize);
/**
* A utility macro to print error message pertaining to the specified error
* code to the log. This macro will construct the error message title
* according to the 'title_fmt' argument, and add the error string pertaining
* to the error code after the title string. A colon (':') will be added
* automatically between the title and the error string.
*
* This function is similar to pj_perror() function, but has the advantage
* that the function call can be omitted from the link process if the
* log level argument is below PJ_LOG_MAX_LEVEL threshold.
*
* Note that the title string constructed from the title_fmt will be built on
* a string buffer which size is PJ_PERROR_TITLE_BUF_SIZE, which normally is
* allocated from the stack. By default this buffer size is small (around
* 120 characters). Application MUST ensure that the constructed title string
* will not exceed this limit, since not all platforms support truncating
* the string.
*
* @see pj_perror()
*
* @param level The logging verbosity level, valid values are 0-6. Lower
* number indicates higher importance, with level zero
* indicates fatal error. Only numeral argument is
* permitted (e.g. not variable).
* @param arg Enclosed 'printf' like arguments, with the following
* arguments:
* - the sender (NULL terminated string),
* - the error code (pj_status_t)
* - the format string (title_fmt), and
* - optional variable number of arguments suitable for the
* format string.
*
* Sample:
* \verbatim
PJ_PERROR(2, (__FILE__, PJ_EBUSY, "Error making %s", "coffee"));
\endverbatim
* @hideinitializer
*/
#define PJ_PERROR(level,arg) do { \
pj_perror_wrapper_##level(arg); \
} while (0)
/**
* A utility function to print error message pertaining to the specified error
* code to the log. This function will construct the error message title
* according to the 'title_fmt' argument, and add the error string pertaining
* to the error code after the title string. A colon (':') will be added
* automatically between the title and the error string.
*
* Unlike the PJ_PERROR() macro, this function takes the \a log_level argument
* as a normal argument, unlike in PJ_PERROR() where a numeral value must be
* given. However this function will always be linked to the executable,
* unlike PJ_PERROR() which can be omitted when the level is below the
* PJ_LOG_MAX_LEVEL.
*
* Note that the title string constructed from the title_fmt will be built on
* a string buffer which size is PJ_PERROR_TITLE_BUF_SIZE, which normally is
* allocated from the stack. By default this buffer size is small (around
* 120 characters). Application MUST ensure that the constructed title string
* will not exceed this limit, since not all platforms support truncating
* the string.
*
* @see PJ_PERROR()
*/
PJ_DECL(void) pj_perror(int log_level, const char *sender, pj_status_t status,
const char *title_fmt, ...)
PJ_PRINT_FUNC_DECOR(4);
/**
* Type of callback to be specified in #pj_register_strerror()
*
* @param e The error code to lookup.
* @param msg Buffer to store the error message.
* @param max Length of the buffer.
*
* @return The error string.
*/
typedef pj_str_t (*pj_error_callback)(pj_status_t e, char *msg, pj_size_t max);
/**
* Register strerror message handler for the specified error space.
* Application can register its own handler to supply the error message
* for the specified error code range. This handler will be called
* by #pj_strerror().
*
* @param start_code The starting error code where the handler should
* be called to retrieve the error message.
* @param err_space The size of error space. The error code range then
* will fall in start_code to start_code+err_space-1
* range.
* @param f The handler to be called when #pj_strerror() is
* supplied with error code that falls into this range.
*
* @return PJ_SUCCESS or the specified error code. The
* registration may fail when the error space has been
* occupied by other handler, or when there are too many
* handlers registered to PJLIB.
*/
PJ_DECL(pj_status_t) pj_register_strerror(pj_status_t start_code,
pj_status_t err_space,
pj_error_callback f);
/**
* @hideinitializer
* Return platform os error code folded into pj_status_t code. This is
* the macro that is used throughout the library for all PJLIB's functions
* that returns error from operating system. Application may override
* this macro to reduce size (e.g. by defining it to always return
* #PJ_EUNKNOWN).
*
* Note:
* This macro MUST return non-zero value regardless whether zero is
* passed as the argument. The reason is to protect logic error when
* the operating system doesn't report error codes properly.
*
* @param os_code Platform OS error code. This value may be evaluated
* more than once.
* @return The platform os error code folded into pj_status_t.
*/
#ifndef PJ_RETURN_OS_ERROR
# define PJ_RETURN_OS_ERROR(os_code) (os_code ? \
PJ_STATUS_FROM_OS(os_code) : -1)
#endif
/**
* @hideinitializer
* Fold a platform specific error into an pj_status_t code.
*
* @param e The platform os error code.
* @return pj_status_t
* @warning Macro implementation; the syserr argument may be evaluated
* multiple times.
*/
#if PJ_NATIVE_ERR_POSITIVE
# define PJ_STATUS_FROM_OS(e) (e == 0 ? PJ_SUCCESS : e + PJ_ERRNO_START_SYS)
#else
# define PJ_STATUS_FROM_OS(e) (e == 0 ? PJ_SUCCESS : PJ_ERRNO_START_SYS - e)
#endif
/**
* @hideinitializer
* Fold an pj_status_t code back to the native platform defined error.
*
* @param e The pj_status_t folded platform os error code.
* @return pj_os_err_type
* @warning macro implementation; the statcode argument may be evaluated
* multiple times. If the statcode was not created by
* pj_get_os_error or PJ_STATUS_FROM_OS, the results are undefined.
*/
#if PJ_NATIVE_ERR_POSITIVE
# define PJ_STATUS_TO_OS(e) (e == 0 ? PJ_SUCCESS : e - PJ_ERRNO_START_SYS)
#else
# define PJ_STATUS_TO_OS(e) (e == 0 ? PJ_SUCCESS : PJ_ERRNO_START_SYS - e)
#endif
/**
* @defgroup pj_errnum PJLIB's Own Error Codes
* @ingroup pj_errno
* @{
*/
/**
* Use this macro to generate error message text for your error code,
* so that they look uniformly as the rest of the libraries.
*
* @param code The error code
* @param msg The error test.
*/
#ifndef PJ_BUILD_ERR
# define PJ_BUILD_ERR(code,msg) { code, msg " (" #code ")" }
#endif
/**
* @hideinitializer
* Unknown error has been reported.
*/
#define PJ_EUNKNOWN (PJ_ERRNO_START_STATUS + 1) /* 70001 */
/**
* @hideinitializer
* The operation is pending and will be completed later.
*/
#define PJ_EPENDING (PJ_ERRNO_START_STATUS + 2) /* 70002 */
/**
* @hideinitializer
* Too many connecting sockets.
*/
#define PJ_ETOOMANYCONN (PJ_ERRNO_START_STATUS + 3) /* 70003 */
/**
* @hideinitializer
* Invalid argument.
*/
#define PJ_EINVAL (PJ_ERRNO_START_STATUS + 4) /* 70004 */
/**
* @hideinitializer
* Name too long (eg. hostname too long).
*/
#define PJ_ENAMETOOLONG (PJ_ERRNO_START_STATUS + 5) /* 70005 */
/**
* @hideinitializer
* Not found.
*/
#define PJ_ENOTFOUND (PJ_ERRNO_START_STATUS + 6) /* 70006 */
/**
* @hideinitializer
* Not enough memory.
*/
#define PJ_ENOMEM (PJ_ERRNO_START_STATUS + 7) /* 70007 */
/**
* @hideinitializer
* Bug detected!
*/
#define PJ_EBUG (PJ_ERRNO_START_STATUS + 8) /* 70008 */
/**
* @hideinitializer
* Operation timed out.
*/
#define PJ_ETIMEDOUT (PJ_ERRNO_START_STATUS + 9) /* 70009 */
/**
* @hideinitializer
* Too many objects.
*/
#define PJ_ETOOMANY (PJ_ERRNO_START_STATUS + 10)/* 70010 */
/**
* @hideinitializer
* Object is busy.
*/
#define PJ_EBUSY (PJ_ERRNO_START_STATUS + 11)/* 70011 */
/**
* @hideinitializer
* The specified option is not supported.
*/
#define PJ_ENOTSUP (PJ_ERRNO_START_STATUS + 12)/* 70012 */
/**
* @hideinitializer
* Invalid operation.
*/
#define PJ_EINVALIDOP (PJ_ERRNO_START_STATUS + 13)/* 70013 */
/**
* @hideinitializer
* Operation is cancelled.
*/
#define PJ_ECANCELLED (PJ_ERRNO_START_STATUS + 14)/* 70014 */
/**
* @hideinitializer
* Object already exists.
*/
#define PJ_EEXISTS (PJ_ERRNO_START_STATUS + 15)/* 70015 */
/**
* @hideinitializer
* End of file.
*/
#define PJ_EEOF (PJ_ERRNO_START_STATUS + 16)/* 70016 */
/**
* @hideinitializer
* Size is too big.
*/
#define PJ_ETOOBIG (PJ_ERRNO_START_STATUS + 17)/* 70017 */
/**
* @hideinitializer
* Error in gethostbyname(). This is a generic error returned when
* gethostbyname() has returned an error.
*/
#define PJ_ERESOLVE (PJ_ERRNO_START_STATUS + 18)/* 70018 */
/**
* @hideinitializer
* Size is too small.
*/
#define PJ_ETOOSMALL (PJ_ERRNO_START_STATUS + 19)/* 70019 */
/**
* @hideinitializer
* Ignored
*/
#define PJ_EIGNORED (PJ_ERRNO_START_STATUS + 20)/* 70020 */
/**
* @hideinitializer
* IPv6 is not supported
*/
#define PJ_EIPV6NOTSUP (PJ_ERRNO_START_STATUS + 21)/* 70021 */
/**
* @hideinitializer
* Unsupported address family
*/
#define PJ_EAFNOTSUP (PJ_ERRNO_START_STATUS + 22)/* 70022 */
/**
* @hideinitializer
* Object no longer exists
*/
#define PJ_EGONE (PJ_ERRNO_START_STATUS + 23)/* 70023 */
/**
* @hideinitializer
* Socket is stopped
*/
#define PJ_ESOCKETSTOP (PJ_ERRNO_START_STATUS + 24)/* 70024 */
/** @} */ /* pj_errnum */
/** @} */ /* pj_errno */
/**
* PJ_ERRNO_START is where PJLIB specific error values start.
*/
#define PJ_ERRNO_START 20000
/**
* PJ_ERRNO_SPACE_SIZE is the maximum number of errors in one of
* the error/status range below.
*/
#define PJ_ERRNO_SPACE_SIZE 50000
/**
* PJ_ERRNO_START_STATUS is where PJLIB specific status codes start.
* Effectively the error in this class would be 70000 - 119000.
*/
#define PJ_ERRNO_START_STATUS (PJ_ERRNO_START + PJ_ERRNO_SPACE_SIZE)
/**
* PJ_ERRNO_START_SYS converts platform specific error codes into
* pj_status_t values.
* Effectively the error in this class would be 120000 - 169000.
*/
#define PJ_ERRNO_START_SYS (PJ_ERRNO_START_STATUS + PJ_ERRNO_SPACE_SIZE)
/**
* PJ_ERRNO_START_USER are reserved for applications that use error
* codes along with PJLIB codes.
* Effectively the error in this class would be 170000 - 219000.
*/
#define PJ_ERRNO_START_USER (PJ_ERRNO_START_SYS + PJ_ERRNO_SPACE_SIZE)
/*
* Below are list of error spaces that have been taken so far:
* - PJSIP_ERRNO_START (PJ_ERRNO_START_USER)
* - PJMEDIA_ERRNO_START (PJ_ERRNO_START_USER + PJ_ERRNO_SPACE_SIZE)
* - PJSIP_SIMPLE_ERRNO_START (PJ_ERRNO_START_USER + PJ_ERRNO_SPACE_SIZE*2)
* - PJLIB_UTIL_ERRNO_START (PJ_ERRNO_START_USER + PJ_ERRNO_SPACE_SIZE*3)
* - PJNATH_ERRNO_START (PJ_ERRNO_START_USER + PJ_ERRNO_SPACE_SIZE*4)
* - PJMEDIA_AUDIODEV_ERRNO_START (PJ_ERRNO_START_USER + PJ_ERRNO_SPACE_SIZE*5)
* - PJ_SSL_ERRNO_START (PJ_ERRNO_START_USER + PJ_ERRNO_SPACE_SIZE*6)
* - PJMEDIA_VIDEODEV_ERRNO_START (PJ_ERRNO_START_USER + PJ_ERRNO_SPACE_SIZE*7)
*/
/** Internal */
void pj_errno_clear_handlers(void);
/****** Internal for PJ_PERROR *******/
/**
* @def pj_perror_wrapper_1(arg)
* Internal function to write log with verbosity 1. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 1.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 1
#define pj_perror_wrapper_1(arg) pj_perror_1 arg
/** Internal function. */
PJ_DECL(void) pj_perror_1(const char *sender, pj_status_t status,
const char *title_fmt, ...)
PJ_PRINT_FUNC_DECOR(3);
#else
#define pj_perror_wrapper_1(arg)
#endif
/**
* @def pj_perror_wrapper_2(arg)
* Internal function to write log with verbosity 2. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 2.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 2
#define pj_perror_wrapper_2(arg) pj_perror_2 arg
/** Internal function. */
PJ_DECL(void) pj_perror_2(const char *sender, pj_status_t status,
const char *title_fmt, ...)
PJ_PRINT_FUNC_DECOR(3);
#else
#define pj_perror_wrapper_2(arg)
#endif
/**
* @def pj_perror_wrapper_3(arg)
* Internal function to write log with verbosity 3. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 3.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 3
#define pj_perror_wrapper_3(arg) pj_perror_3 arg
/** Internal function. */
PJ_DECL(void) pj_perror_3(const char *sender, pj_status_t status,
const char *title_fmt, ...)
PJ_PRINT_FUNC_DECOR(3);
#else
#define pj_perror_wrapper_3(arg)
#endif
/**
* @def pj_perror_wrapper_4(arg)
* Internal function to write log with verbosity 4. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 4.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 4
#define pj_perror_wrapper_4(arg) pj_perror_4 arg
/** Internal function. */
PJ_DECL(void) pj_perror_4(const char *sender, pj_status_t status,
const char *title_fmt, ...)
PJ_PRINT_FUNC_DECOR(3);
#else
#define pj_perror_wrapper_4(arg)
#endif
/**
* @def pj_perror_wrapper_5(arg)
* Internal function to write log with verbosity 5. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 5.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 5
#define pj_perror_wrapper_5(arg) pj_perror_5 arg
/** Internal function. */
PJ_DECL(void) pj_perror_5(const char *sender, pj_status_t status,
const char *title_fmt, ...)
PJ_PRINT_FUNC_DECOR(3);
#else
#define pj_perror_wrapper_5(arg)
#endif
/**
* @def pj_perror_wrapper_6(arg)
* Internal function to write log with verbosity 6. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 6.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 6
#define pj_perror_wrapper_6(arg) pj_perror_6 arg
/** Internal function. */
PJ_DECL(void) pj_perror_6(const char *sender, pj_status_t status,
const char *title_fmt, ...)
PJ_PRINT_FUNC_DECOR(3);
#else
#define pj_perror_wrapper_6(arg)
#endif
PJ_END_DECL
#endif /* __PJ_ERRNO_H__ */

420
GSMGateway/app/src/main/cpp/pj/except.h Normal file
View File

@@ -0,0 +1,420 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_EXCEPTION_H__
#define __PJ_EXCEPTION_H__
/**
* @file except.h
* @brief Exception Handling in C.
*/
#include <pj/types.h>
#include <pj/compat/setjmp.h>
#include <pj/log.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_EXCEPT Exception Handling
* @ingroup PJ_MISC
* @{
*
* \section pj_except_sample_sec Quick Example
*
* For the impatient, take a look at some examples:
* - Exception Handling sample: \src{pjlib/src/pjlib-samples/except.c}
* - Exception Handling test: \src{pjlib/src/pjlib-test/exception.c}
*
* \section pj_except_except Exception Handling
*
* This module provides exception handling syntactically similar to C++ in
* C language. In Win32 systems, it uses Windows Structured Exception
* Handling (SEH) if macro PJ_EXCEPTION_USE_WIN32_SEH is non-zero.
* Otherwise it will use setjmp() and longjmp().
*
* On some platforms where setjmp/longjmp is not available, setjmp/longjmp
* implementation is provided. See <pj/compat/setjmp.h> for compatibility.
*
* The exception handling mechanism is completely thread safe, so the exception
* thrown by one thread will not interfere with other thread.
*
* The exception handling constructs are similar to C++. The blocks will be
* constructed similar to the following sample:
*
* \verbatim
#define NO_MEMORY 1
#define SYNTAX_ERROR 2
int sample1()
{
PJ_USE_EXCEPTION; // declare local exception stack.
PJ_TRY {
...// do something..
}
PJ_CATCH(NO_MEMORY) {
... // handle exception 1
}
PJ_END;
}
int sample2()
{
PJ_USE_EXCEPTION; // declare local exception stack.
PJ_TRY {
...// do something..
}
PJ_CATCH_ANY {
if (PJ_GET_EXCEPTION() == NO_MEMORY)
...; // handle no memory situation
else if (PJ_GET_EXCEPTION() == SYNTAX_ERROR)
...; // handle syntax error
}
PJ_END;
}
\endverbatim
*
* The above sample uses hard coded exception ID. It is @b strongly
* recommended that applications request a unique exception ID instead
* of hard coded value like above.
*
* \section pj_except_reg Exception ID Allocation
*
* To ensure that exception ID (number) are used consistently and to
* prevent ID collisions in an application, it is strongly suggested that
* applications allocate an exception ID for each possible exception
* type. As a bonus of this process, the application can identify
* the name of the exception when the particular exception is thrown.
*
* Exception ID management are performed with the following APIs:
* - #pj_exception_id_alloc().
* - #pj_exception_id_free().
* - #pj_exception_id_name().
*
*
* PJLIB itself automatically allocates one exception id, i.e.
* #PJ_NO_MEMORY_EXCEPTION which is declared in <pj/pool.h>. This exception
* ID is raised by default pool policy when it fails to allocate memory.
*
* CAVEATS:
* - unlike C++ exception, the scheme here won't call destructors of local
* objects if exception is thrown. Care must be taken when a function
* hold some resorce such as pool or mutex etc.
* - You CAN NOT make nested exception in one single function without using
* a nested PJ_USE_EXCEPTION. Samples:
\verbatim
void wrong_sample()
{
PJ_USE_EXCEPTION;
PJ_TRY {
// Do stuffs
...
}
PJ_CATCH_ANY {
// Do other stuffs
....
..
// The following block is WRONG! You MUST declare
// PJ_USE_EXCEPTION once again in this block.
PJ_TRY {
..
}
PJ_CATCH_ANY {
..
}
PJ_END;
}
PJ_END;
}
\endverbatim
* - You MUST NOT exit the function inside the PJ_TRY block. The correct way
* is to return from the function after PJ_END block is executed.
* For example, the following code will yield crash not in this code,
* but rather in the subsequent execution of PJ_TRY block:
\verbatim
void wrong_sample()
{
PJ_USE_EXCEPTION;
PJ_TRY {
// do some stuffs
...
return; <======= DO NOT DO THIS!
}
PJ_CATCH_ANY {
}
PJ_END;
}
\endverbatim
* - You can not provide more than PJ_CATCH or PJ_CATCH_ANY nor use PJ_CATCH
* and PJ_CATCH_ANY for a single PJ_TRY.
* - Exceptions will always be caught by the first handler (unlike C++ where
* exception is only caught if the type matches.
* \section PJ_EX_KEYWORDS Keywords
*
* \subsection PJ_THROW PJ_THROW(expression)
* Throw an exception. The expression thrown is an integer as the result of
* the \a expression. This keyword can be specified anywhere within the
* program.
*
* \subsection PJ_USE_EXCEPTION PJ_USE_EXCEPTION
* Specify this in the variable definition section of the function block
* (or any blocks) to specify that the block has \a PJ_TRY/PJ_CATCH exception
* block.
* Actually, this is just a macro to declare local variable which is used to
* push the exception state to the exception stack.
* Note: you must specify PJ_USE_EXCEPTION as the last statement in the
* local variable declarations, since it may evaluate to nothing.
*
* \subsection PJ_TRY PJ_TRY
* The \a PJ_TRY keyword is typically followed by a block. If an exception is
* thrown in this block, then the execution will resume to the \a PJ_CATCH
* handler.
*
* \subsection PJ_CATCH PJ_CATCH(expression)
* The \a PJ_CATCH is normally followed by a block. This block will be executed
* if the exception being thrown is equal to the expression specified in the
* \a PJ_CATCH.
*
* \subsection PJ_CATCH_ANY PJ_CATCH_ANY
* The \a PJ_CATCH is normally followed by a block. This block will be executed
* if any exception was raised in the TRY block.
*
* \subsection PJ_END PJ_END
* Specify this keyword to mark the end of \a PJ_TRY / \a PJ_CATCH blocks.
*
* \subsection PJ_GET_EXCEPTION PJ_GET_EXCEPTION(void)
* Get the last exception thrown. This macro is normally called inside the
* \a PJ_CATCH or \a PJ_CATCH_ANY block, altough it can be used anywhere where
* the \a PJ_USE_EXCEPTION definition is in scope.
*
*
* \section pj_except_examples_sec Examples
*
* For some examples on how to use the exception construct, please see:
* - Exception Handling sample: \src{pjlib/src/pjlib-samples/except.c}
* - Exception Handling test: \src{pjlib/src/pjlib-test/exception.c}
*/
/**
* Allocate a unique exception id.
* Applications don't have to allocate a unique exception ID before using
* the exception construct. However, by doing so it ensures that there is
* no collisions of exception ID.
*
* As a bonus, when exception number is acquired through this function,
* the library can assign name to the exception (only if
* PJ_HAS_EXCEPTION_NAMES is enabled (default is yes)) and find out the
* exception name when it catches an exception.
*
* @param name Name to be associated with the exception ID.
* @param id Pointer to receive the ID.
*
* @return PJ_SUCCESS on success or PJ_ETOOMANY if the library
* is running out out ids.
*/
PJ_DECL(pj_status_t) pj_exception_id_alloc(const char *name,
pj_exception_id_t *id);
/**
* Free an exception id.
*
* @param id The exception ID.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_exception_id_free(pj_exception_id_t id);
/**
* Retrieve name associated with the exception id.
*
* @param id The exception ID.
*
* @return The name associated with the specified ID.
*/
PJ_DECL(const char*) pj_exception_id_name(pj_exception_id_t id);
/** @} */
#if defined(PJ_EXCEPTION_USE_WIN32_SEH) && PJ_EXCEPTION_USE_WIN32_SEH != 0
/*****************************************************************************
**
** IMPLEMENTATION OF EXCEPTION USING WINDOWS SEH
**
****************************************************************************/
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
PJ_IDECL_NO_RETURN(void)
pj_throw_exception_(pj_exception_id_t id) PJ_ATTR_NORETURN
{
RaiseException(id,1,0,NULL);
}
#define PJ_USE_EXCEPTION
#define PJ_TRY __try
#define PJ_CATCH(id) __except(GetExceptionCode()==id ? \
EXCEPTION_EXECUTE_HANDLER : \
EXCEPTION_CONTINUE_SEARCH)
#define PJ_CATCH_ANY __except(EXCEPTION_EXECUTE_HANDLER)
#define PJ_END
#define PJ_THROW(id) pj_throw_exception_(id)
#define PJ_GET_EXCEPTION() GetExceptionCode()
#elif defined(PJ_SYMBIAN) && PJ_SYMBIAN!=0
/*****************************************************************************
**
** IMPLEMENTATION OF EXCEPTION USING SYMBIAN LEAVE/TRAP FRAMEWORK
**
****************************************************************************/
/* To include this file, the source file must be compiled as
* C++ code!
*/
#ifdef __cplusplus
class TPjException
{
public:
int code_;
};
#define PJ_USE_EXCEPTION
#define PJ_TRY try
//#define PJ_CATCH(id)
#define PJ_CATCH_ANY catch (const TPjException & pj_excp_)
#define PJ_END
#define PJ_THROW(x_id) do { TPjException e; e.code_=x_id; throw e;} \
while (0)
#define PJ_GET_EXCEPTION() pj_excp_.code_
#else
#define PJ_USE_EXCEPTION
#define PJ_TRY
#define PJ_CATCH_ANY if (0)
#define PJ_END
#define PJ_THROW(x_id) do { PJ_LOG(1,("PJ_THROW"," error code = %d",x_id)); } while (0)
#define PJ_GET_EXCEPTION() 0
#endif /* __cplusplus */
#else
/*****************************************************************************
**
** IMPLEMENTATION OF EXCEPTION USING GENERIC SETJMP/LONGJMP
**
****************************************************************************/
/**
* This structure (which should be invisible to user) manages the TRY handler
* stack.
*/
struct pj_exception_state_t
{
pj_jmp_buf state; /**< jmp_buf. */
struct pj_exception_state_t *prev; /**< Previous state in the list. */
};
/**
* Throw exception.
* @param id Exception Id.
*/
PJ_DECL_NO_RETURN(void)
pj_throw_exception_(pj_exception_id_t id) PJ_ATTR_NORETURN;
/**
* Push exception handler.
*/
PJ_DECL(void) pj_push_exception_handler_(struct pj_exception_state_t *rec);
/**
* Pop exception handler.
*/
PJ_DECL(void) pj_pop_exception_handler_(struct pj_exception_state_t *rec);
/**
* Declare that the function will use exception.
* @hideinitializer
*/
#define PJ_USE_EXCEPTION struct pj_exception_state_t pj_x_except__; int pj_x_code__
/**
* Start exception specification block.
* @hideinitializer
*/
#define PJ_TRY if (1) { \
pj_push_exception_handler_(&pj_x_except__); \
pj_x_code__ = pj_setjmp(pj_x_except__.state); \
if (pj_x_code__ == 0)
/**
* Catch the specified exception Id.
* @param id The exception number to catch.
* @hideinitializer
*/
#define PJ_CATCH(id) else if (pj_x_code__ == (id))
/**
* Catch any exception number.
* @hideinitializer
*/
#define PJ_CATCH_ANY else
/**
* End of exception specification block.
* @hideinitializer
*/
#define PJ_END pj_pop_exception_handler_(&pj_x_except__); \
} else {}
/**
* Throw exception.
* @param exception_id The exception number.
* @hideinitializer
*/
#define PJ_THROW(exception_id) pj_throw_exception_(exception_id)
/**
* Get current exception.
* @return Current exception code.
* @hideinitializer
*/
#define PJ_GET_EXCEPTION() (pj_x_code__)
#endif /* PJ_EXCEPTION_USE_WIN32_SEH */
PJ_END_DECL
#endif /* __PJ_EXCEPTION_H__ */

43
GSMGateway/app/src/main/cpp/pj/fifobuf.h Normal file
View File

@@ -0,0 +1,43 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_FIFOBUF_H__
#define __PJ_FIFOBUF_H__
#include <pj/types.h>
PJ_BEGIN_DECL
typedef struct pj_fifobuf_t pj_fifobuf_t;
struct pj_fifobuf_t
{
char *first, *last;
char *ubegin, *uend;
int full;
};
PJ_DECL(void) pj_fifobuf_init (pj_fifobuf_t *fb, void *buffer, unsigned size);
PJ_DECL(unsigned) pj_fifobuf_max_size (pj_fifobuf_t *fb);
PJ_DECL(void*) pj_fifobuf_alloc (pj_fifobuf_t *fb, unsigned size);
PJ_DECL(pj_status_t) pj_fifobuf_unalloc (pj_fifobuf_t *fb, void *buf);
PJ_DECL(pj_status_t) pj_fifobuf_free (pj_fifobuf_t *fb, void *buf);
PJ_END_DECL
#endif /* __PJ_FIFOBUF_H__ */

108
GSMGateway/app/src/main/cpp/pj/file_access.h Normal file
View File

@@ -0,0 +1,108 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_FILE_ACCESS_H__
#define __PJ_FILE_ACCESS_H__
/**
* @file file_access.h
* @brief File manipulation and access.
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_FILE_ACCESS File Access
* @ingroup PJ_IO
* @{
*
*/
/**
* This structure describes file information, to be obtained by
* calling #pj_file_getstat(). The time information in this structure
* is in local time.
*/
typedef struct pj_file_stat
{
pj_off_t size; /**< Total file size. */
pj_time_val atime; /**< Time of last access. */
pj_time_val mtime; /**< Time of last modification. */
pj_time_val ctime; /**< Time of last creation. */
} pj_file_stat;
/**
* Returns non-zero if the specified file exists.
*
* @param filename The file name.
*
* @return Non-zero if the file exists.
*/
PJ_DECL(pj_bool_t) pj_file_exists(const char *filename);
/**
* Returns the size of the file.
*
* @param filename The file name.
*
* @return The file size in bytes or -1 on error.
*/
PJ_DECL(pj_off_t) pj_file_size(const char *filename);
/**
* Delete a file.
*
* @param filename The filename.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_file_delete(const char *filename);
/**
* Move a \c oldname to \c newname. If \c newname already exists,
* it will be overwritten.
*
* @param oldname The file to rename.
* @param newname New filename to assign.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_file_move( const char *oldname,
const char *newname);
/**
* Return information about the specified file. The time information in
* the \c stat structure will be in local time.
*
* @param filename The filename.
* @param stat Pointer to variable to receive file information.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_file_getstat(const char *filename, pj_file_stat *stat);
/** @} */
PJ_END_DECL
#endif /* __PJ_FILE_ACCESS_H__ */

183
GSMGateway/app/src/main/cpp/pj/file_io.h Normal file
View File

@@ -0,0 +1,183 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_FILE_IO_H__
#define __PJ_FILE_IO_H__
/**
* @file file_io.h
* @brief Simple file I/O abstraction.
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_FILE_IO File I/O
* @ingroup PJ_IO
* @{
*
* This file contains functionalities to perform file I/O. The file
* I/O can be implemented with various back-end, either using native
* file API or ANSI stream.
*
* @section pj_file_size_limit_sec Size Limits
*
* There may be limitation on the size that can be handled by the
* #pj_file_setpos() or #pj_file_getpos() functions. The API itself
* uses 64-bit integer for the file offset/position (where available);
* however some backends (such as ANSI) may only support signed 32-bit
* offset resolution.
*
* Reading and writing operation uses signed 32-bit integer to indicate
* the size.
*
*
*/
/**
* These enumerations are used when opening file. Values PJ_O_RDONLY,
* PJ_O_WRONLY, and PJ_O_RDWR are mutually exclusive. Value PJ_O_APPEND
* can only be used when the file is opened for writing.
*/
enum pj_file_access
{
PJ_O_RDONLY = 0x1101, /**< Open file for reading. */
PJ_O_WRONLY = 0x1102, /**< Open file for writing. */
PJ_O_RDWR = 0x1103, /**< Open file for reading and writing.
File will be truncated. */
PJ_O_APPEND = 0x1108, /**< Append to existing file. */
PJ_O_CLOEXEC = 0x1104, /**< Enable unix close-on-exec flag. */
};
/**
* The seek directive when setting the file position with #pj_file_setpos.
*/
enum pj_file_seek_type
{
PJ_SEEK_SET = 0x1201, /**< Offset from beginning of the file. */
PJ_SEEK_CUR = 0x1202, /**< Offset from current position. */
PJ_SEEK_END = 0x1203 /**< Size of the file plus offset. */
};
/**
* Open the file as specified in \c pathname with the specified
* mode, and return the handle in \c fd. All files will be opened
* as binary.
*
* @param pool Pool to allocate memory for the new file descriptor.
* @param pathname The file name to open.
* @param flags Open flags, which is bitmask combination of
* #pj_file_access enum. The flag must be either
* PJ_O_RDONLY, PJ_O_WRONLY, or PJ_O_RDWR. When file
* writing is specified, existing file will be
* truncated unless PJ_O_APPEND is specified.
* @param fd The returned descriptor.
*
* @return PJ_SUCCESS or the appropriate error code on error.
*/
PJ_DECL(pj_status_t) pj_file_open(pj_pool_t *pool,
const char *pathname,
unsigned flags,
pj_oshandle_t *fd);
/**
* Close an opened file descriptor.
*
* @param fd The file descriptor.
*
* @return PJ_SUCCESS or the appropriate error code on error.
*/
PJ_DECL(pj_status_t) pj_file_close(pj_oshandle_t fd);
/**
* Write data with the specified size to an opened file.
*
* @param fd The file descriptor.
* @param data Data to be written to the file.
* @param size On input, specifies the size of data to be written.
* On return, it contains the number of data actually
* written to the file.
*
* @return PJ_SUCCESS or the appropriate error code on error.
*/
PJ_DECL(pj_status_t) pj_file_write(pj_oshandle_t fd,
const void *data,
pj_ssize_t *size);
/**
* Read data from the specified file. When end-of-file condition is set,
* this function will return PJ_SUCCESS but the size will contain zero.
*
* @param fd The file descriptor.
* @param data Pointer to buffer to receive the data.
* @param size On input, specifies the maximum number of data to
* read from the file. On output, it contains the size
* of data actually read from the file. It will contain
* zero when EOF occurs.
*
* @return PJ_SUCCESS or the appropriate error code on error.
* When EOF occurs, the return is PJ_SUCCESS but size
* will report zero.
*/
PJ_DECL(pj_status_t) pj_file_read(pj_oshandle_t fd,
void *data,
pj_ssize_t *size);
/**
* Set file position to new offset according to directive \c whence.
*
* @param fd The file descriptor.
* @param offset The new file position to set.
* @param whence The directive.
*
* @return PJ_SUCCESS or the appropriate error code on error.
*/
PJ_DECL(pj_status_t) pj_file_setpos(pj_oshandle_t fd,
pj_off_t offset,
enum pj_file_seek_type whence);
/**
* Get current file position.
*
* @param fd The file descriptor.
* @param pos On return contains the file position as measured
* from the beginning of the file.
*
* @return PJ_SUCCESS or the appropriate error code on error.
*/
PJ_DECL(pj_status_t) pj_file_getpos(pj_oshandle_t fd,
pj_off_t *pos);
/**
* Flush file buffers.
*
* @param fd The file descriptor.
*
* @return PJ_SUCCESS or the appropriate error code on error.
*/
PJ_DECL(pj_status_t) pj_file_flush(pj_oshandle_t fd);
/** @} */
PJ_END_DECL
#endif /* __PJ_FILE_IO_H__ */

119
GSMGateway/app/src/main/cpp/pj/guid.h Normal file
View File

@@ -0,0 +1,119 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_GUID_H__
#define __PJ_GUID_H__
/**
* @file guid.h
* @brief GUID Globally Unique Identifier.
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_DS Data Structure.
*/
/**
* @defgroup PJ_GUID Globally Unique Identifier
* @ingroup PJ_DS
* @{
*
* This module provides API to create string that is globally unique.
* If application doesn't require that strong requirement, it can just
* use #pj_create_random_string() instead.
*/
/**
* PJ_GUID_STRING_LENGTH specifies length of GUID string. The value is
* dependent on the algorithm used internally to generate the GUID string.
* If real GUID generator is used, then the length will be between 32 and
* 36 bytes. Application should not assume which algorithm will
* be used by GUID generator.
*
* Regardless of the actual length of the GUID, it will not exceed
* PJ_GUID_MAX_LENGTH characters.
*
* @see pj_GUID_STRING_LENGTH()
* @see PJ_GUID_MAX_LENGTH
*/
PJ_DECL_DATA(const unsigned) PJ_GUID_STRING_LENGTH;
/**
* Get #PJ_GUID_STRING_LENGTH constant.
*/
PJ_DECL(unsigned) pj_GUID_STRING_LENGTH(void);
/**
* PJ_GUID_MAX_LENGTH specifies the maximum length of GUID string,
* regardless of which algorithm to use.
*/
#define PJ_GUID_MAX_LENGTH 36
/**
* Create a globally unique string, which length is PJ_GUID_STRING_LENGTH
* characters. Caller is responsible for preallocating the storage used
* in the string.
*
* @param str The string to store the result.
*
* @return The string.
*/
PJ_DECL(pj_str_t*) pj_generate_unique_string(pj_str_t *str);
/**
* Create a globally unique string in lowercase, which length is
* PJ_GUID_STRING_LENGTH characters. Caller is responsible for preallocating
* the storage used in the string.
*
* @param str The string to store the result.
*
* @return The string.
*/
PJ_DECL(pj_str_t*) pj_generate_unique_string_lower(pj_str_t *str);
/**
* Generate a unique string.
*
* @param pool Pool to allocate memory from.
* @param str The string.
*/
PJ_DECL(void) pj_create_unique_string(pj_pool_t *pool, pj_str_t *str);
/**
* Generate a unique string in lowercase.
*
* @param pool Pool to allocate memory from.
* @param str The string.
*/
PJ_DECL(void) pj_create_unique_string_lower(pj_pool_t *pool, pj_str_t *str);
/**
* @}
*/
PJ_END_DECL
#endif/* __PJ_GUID_H__ */

253
GSMGateway/app/src/main/cpp/pj/hash.h Normal file
View File

@@ -0,0 +1,253 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_HASH_H__
#define __PJ_HASH_H__
/**
* @file hash.h
* @brief Hash Table.
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_HASH Hash Table
* @ingroup PJ_DS
* @{
* A hash table is a dictionary in which keys are mapped to array positions by
* hash functions. Having the keys of more than one item map to the same
* position is called a collision. In this library, we will chain the nodes
* that have the same key in a list.
*/
/**
* If this constant is used as keylen, then the key is interpreted as
* NULL terminated string.
*/
#define PJ_HASH_KEY_STRING ((unsigned)-1)
/**
* This indicates the size of of each hash entry.
*/
#define PJ_HASH_ENTRY_BUF_SIZE (3*sizeof(void*) + 2*sizeof(pj_uint32_t))
/**
* Type declaration for entry buffer, used by #pj_hash_set_np()
*/
typedef void *pj_hash_entry_buf[(PJ_HASH_ENTRY_BUF_SIZE+sizeof(void*)-1)/(sizeof(void*))];
/**
* This is the function that is used by the hash table to calculate hash value
* of the specified key.
*
* @param hval the initial hash value, or zero.
* @param key the key to calculate.
* @param keylen the length of the key, or PJ_HASH_KEY_STRING to treat
* the key as null terminated string.
*
* @return the hash value.
*/
PJ_DECL(pj_uint32_t) pj_hash_calc(pj_uint32_t hval,
const void *key, unsigned keylen);
/**
* Convert the key to lowercase and calculate the hash value. The resulting
* string is stored in \c result.
*
* @param hval The initial hash value, normally zero.
* @param result Optional. Buffer to store the result, which must be enough
* to hold the string.
* @param key The input key to be converted and calculated.
*
* @return The hash value.
*/
PJ_DECL(pj_uint32_t) pj_hash_calc_tolower(pj_uint32_t hval,
char *result,
const pj_str_t *key);
/**
* Create a hash table with the specified 'bucket' size.
*
* @param pool the pool from which the hash table will be allocated from.
* @param size the bucket size, which will be round-up to the nearest 2^n-1
*
* @return the hash table.
*/
PJ_DECL(pj_hash_table_t*) pj_hash_create(pj_pool_t *pool, unsigned size);
/**
* Get the value associated with the specified key.
*
* @param ht the hash table.
* @param key the key to look for.
* @param keylen the length of the key, or PJ_HASH_KEY_STRING to use the
* string length of the key.
* @param hval if this argument is not NULL and the value is not zero,
* the value will be used as the computed hash value. If
* the argument is not NULL and the value is zero, it will
* be filled with the computed hash upon return.
*
* @return the value associated with the key, or NULL if the key is not found.
*/
PJ_DECL(void *) pj_hash_get( pj_hash_table_t *ht,
const void *key, unsigned keylen,
pj_uint32_t *hval );
/**
* Variant of #pj_hash_get() with the key being converted to lowercase when
* calculating the hash value.
*
* @see pj_hash_get()
*/
PJ_DECL(void *) pj_hash_get_lower( pj_hash_table_t *ht,
const void *key, unsigned keylen,
pj_uint32_t *hval );
/**
* Associate/disassociate a value with the specified key. If value is not
* NULL and entry already exists, the entry's value will be overwritten.
* If value is not NULL and entry does not exist, a new one will be created
* with the specified pool. Otherwise if value is NULL, entry will be
* deleted if it exists.
*
* @param pool the pool to allocate the new entry if a new entry has to be
* created.
* @param ht the hash table.
* @param key the key. If pool is not specified, the key MUST point to
* buffer that remains valid for the duration of the entry.
* @param keylen the length of the key, or PJ_HASH_KEY_STRING to use the
* string length of the key.
* @param hval if the value is not zero, then the hash table will use
* this value to search the entry's index, otherwise it will
* compute the key. This value can be obtained when calling
* #pj_hash_get().
* @param value value to be associated, or NULL to delete the entry with
* the specified key.
*/
PJ_DECL(void) pj_hash_set( pj_pool_t *pool, pj_hash_table_t *ht,
const void *key, unsigned keylen, pj_uint32_t hval,
void *value );
/**
* Variant of #pj_hash_set() with the key being converted to lowercase when
* calculating the hash value.
*
* @see pj_hash_set()
*/
PJ_DECL(void) pj_hash_set_lower( pj_pool_t *pool, pj_hash_table_t *ht,
const void *key, unsigned keylen,
pj_uint32_t hval, void *value );
/**
* Associate/disassociate a value with the specified key. This function works
* like #pj_hash_set(), except that it doesn't use pool (hence the np -- no
* pool suffix). If new entry needs to be allocated, it will use the entry_buf.
*
* @param ht the hash table.
* @param key the key.
* @param keylen the length of the key, or PJ_HASH_KEY_STRING to use the
* string length of the key.
* @param hval if the value is not zero, then the hash table will use
* this value to search the entry's index, otherwise it will
* compute the key. This value can be obtained when calling
* #pj_hash_get().
* @param entry_buf Buffer which will be used for the new entry, when one needs
* to be created.
* @param value value to be associated, or NULL to delete the entry with
* the specified key.
*/
PJ_DECL(void) pj_hash_set_np(pj_hash_table_t *ht,
const void *key, unsigned keylen,
pj_uint32_t hval, pj_hash_entry_buf entry_buf,
void *value);
/**
* Variant of #pj_hash_set_np() with the key being converted to lowercase
* when calculating the hash value.
*
* @see pj_hash_set_np()
*/
PJ_DECL(void) pj_hash_set_np_lower(pj_hash_table_t *ht,
const void *key, unsigned keylen,
pj_uint32_t hval,
pj_hash_entry_buf entry_buf,
void *value);
/**
* Get the total number of entries in the hash table.
*
* @param ht the hash table.
*
* @return the number of entries in the hash table.
*/
PJ_DECL(unsigned) pj_hash_count( pj_hash_table_t *ht );
/**
* Get the iterator to the first element in the hash table.
*
* @param ht the hash table.
* @param it the iterator for iterating hash elements.
*
* @return the iterator to the hash element, or NULL if no element presents.
*/
PJ_DECL(pj_hash_iterator_t*) pj_hash_first( pj_hash_table_t *ht,
pj_hash_iterator_t *it );
/**
* Get the next element from the iterator.
*
* @param ht the hash table.
* @param it the hash iterator.
*
* @return the next iterator, or NULL if there's no more element.
*/
PJ_DECL(pj_hash_iterator_t*) pj_hash_next( pj_hash_table_t *ht,
pj_hash_iterator_t *it );
/**
* Get the value associated with a hash iterator.
*
* @param ht the hash table.
* @param it the hash iterator.
*
* @return the value associated with the current element in iterator.
*/
PJ_DECL(void*) pj_hash_this( pj_hash_table_t *ht,
pj_hash_iterator_t *it );
/**
* @}
*/
PJ_END_DECL
#endif

955
GSMGateway/app/src/main/cpp/pj/ioqueue.h Normal file
View File

@@ -0,0 +1,955 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_IOQUEUE_H__
#define __PJ_IOQUEUE_H__
/**
* @file ioqueue.h
* @brief I/O Dispatching Mechanism
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_IO Input/Output
* @brief Input/Output
* @ingroup PJ_OS
*
* This section contains API building blocks to perform network I/O and
* communications. If provides:
* - @ref PJ_SOCK
*\n
* A highly portable socket abstraction, runs on all kind of
* network APIs such as standard BSD socket, Windows socket, Linux
* \b kernel socket, PalmOS networking API, etc.
*
* - @ref pj_addr_resolve
*\n
* Portable address resolution, which implements #pj_gethostbyname().
*
* - @ref PJ_SOCK_SELECT
*\n
* A portable \a select() like API (#pj_sock_select()) which can be
* implemented with various back-ends.
*
* - @ref PJ_IOQUEUE
*\n
* Framework for dispatching network events.
*
* For more information see the modules below.
*/
/**
* @defgroup PJ_IOQUEUE IOQueue: I/O Event Dispatching with Proactor Pattern
* @ingroup PJ_IO
* @{
*
* I/O Queue provides API for performing asynchronous I/O operations. It
* conforms to proactor pattern, which allows application to submit an
* asynchronous operation and to be notified later when the operation has
* completed.
*
* The I/O Queue can work on both socket and file descriptors. For
* asynchronous file operations however, one must make sure that the correct
* file I/O back-end is used, because not all file I/O back-end can be
* used with the ioqueue. Please see \ref PJ_FILE_IO for more details.
*
* The framework works natively in platforms where asynchronous operation API
* exists, such as in Windows NT with IoCompletionPort/IOCP. In other
* platforms, the I/O queue abstracts the operating system's event poll API
* to provide semantics similar to IoCompletionPort with minimal penalties
* (i.e. per ioqueue and per handle mutex protection).
*
* The I/O queue provides more than just unified abstraction. It also:
* - makes sure that the operation uses the most effective way to utilize
* the underlying mechanism, to achieve the maximum theoritical
* throughput possible on a given platform.
* - choose the most efficient mechanism for event polling on a given
* platform.
*
* Currently, the I/O Queue is implemented using:
* - <tt><b>select()</b></tt>, as the common denominator, but the least
* efficient. Also the number of descriptor is limited to
* \c PJ_IOQUEUE_MAX_HANDLES (which by default is 64).
* - <tt><b>/dev/epoll</b></tt> on Linux (user mode and kernel mode),
* a much faster replacement for select() on Linux (and more importantly
* doesn't have limitation on number of descriptors).
* - <b>I/O Completion ports</b> on Windows NT/2000/XP, which is the most
* efficient way to dispatch events in Windows NT based OSes, and most
* importantly, it doesn't have the limit on how many handles to monitor.
* And it works with files (not only sockets) as well.
*
*
* \section pj_ioqueue_concurrency_sec Concurrency Rules
*
* The ioqueue has been fine tuned to allow multiple threads to poll the
* handles simultaneously, to maximize scalability when the application is
* running on multiprocessor systems. When more than one threads are polling
* the ioqueue and there are more than one handles are signaled, more than
* one threads will execute the callback simultaneously to serve the events.
* These parallel executions are completely safe when the events happen for
* two different handles.
*
* However, with multithreading, care must be taken when multiple events
* happen on the same handle, or when event is happening on a handle (and
* the callback is being executed) and application is performing
* unregistration to the handle at the same time.
*
* The treatments of above scenario differ according to the concurrency
* setting that are applied to the handle.
*
* \subsection pj_ioq_concur_set Concurrency Settings for Handles
*
* Concurrency can be set on per handle (key) basis, by using
* #pj_ioqueue_set_concurrency() function. The default key concurrency value
* for the handle is inherited from the key concurrency setting of the ioqueue,
* and the key concurrency setting for the ioqueue can be changed by using
* #pj_ioqueue_set_default_concurrency(). The default key concurrency setting
* for ioqueue itself is controlled by compile time setting
* PJ_IOQUEUE_DEFAULT_ALLOW_CONCURRENCY.
*
* Note that this key concurrency setting only controls whether multiple
* threads are allowed to operate <b>on the same key</b> at the same time.
* The ioqueue itself always allows multiple threads to enter the ioqeuue at
* the same time, and also simultaneous callback calls to <b>differrent
* keys</b> is always allowed regardless to the key concurrency setting.
*
* \subsection pj_ioq_parallel Parallel Callback Executions for the Same Handle
*
* Note that when key concurrency is enabled (i.e. parallel callback calls on
* the same key is allowed; this is the default setting), the ioqueue will only
* perform simultaneous callback executions on the same key when the key has
* invoked multiple pending operations. This could be done for example by
* calling #pj_ioqueue_recvfrom() more than once on the same key, each with
* the same key but different operation key (pj_ioqueue_op_key_t). With this
* scenario, when multiple packets arrive on the key at the same time, more
* than one threads may execute the callback simultaneously, each with the
* same key but different operation key.
*
* When there is only one pending operation on the key (e.g. there is only one
* #pj_ioqueue_recvfrom() invoked on the key), then events occuring to the
* same key will be queued by the ioqueue, thus no simultaneous callback calls
* will be performed.
*
* \subsection pj_ioq_allow_concur Concurrency is Enabled (Default Value)
*
* The default setting for the ioqueue is to allow multiple threads to
* execute callbacks for the same handle/key. This setting is selected to
* promote good performance and scalability for application.
*
* However this setting has a major drawback with regard to synchronization,
* and application MUST carefully follow the following guidelines to ensure
* that parallel access to the key does not cause problems:
*
* - Always note that callback may be called simultaneously for the same
* key.
* - <b>Care must be taken when unregistering a key</b> from the
* ioqueue. Application must take care that when one thread is issuing
* an unregistration, other thread is not simultaneously invoking the
* callback <b>to the same key</b>.
*\n
* This happens because the ioqueue functions are working with a pointer
* to the key, and there is a possible race condition where the pointer
* has been rendered invalid by other threads before the ioqueue has a
* chance to acquire mutex on it.
*
* \subsection pj_ioq_disallow_concur Concurrency is Disabled
*
* Alternatively, application may disable key concurrency to make
* synchronization easier. As noted above, there are three ways to control
* key concurrency setting:
* - by controlling on per handle/key basis, with #pj_ioqueue_set_concurrency().
* - by changing default key concurrency setting on the ioqueue, with
* #pj_ioqueue_set_default_concurrency().
* - by changing the default concurrency on compile time, by declaring
* PJ_IOQUEUE_DEFAULT_ALLOW_CONCURRENCY macro to zero in your config_site.h
*
* \section pj_ioqeuue_examples_sec Examples
*
* For some examples on how to use the I/O Queue, please see:
*
* - I/O Queue TCP test: \src{pjlib/src/pjlib-test/ioq_tcp.c}
* - I/O Queue UDP test: \src{pjlib/src/pjlib-test/ioq_udp.c}
* - I/O Queue Performance test: \src{pjlib/src/pjlib-test/ioq_perf.c}
*/
/**
* This structure describes operation specific key to be submitted to
* I/O Queue when performing the asynchronous operation. This key will
* be returned to the application when completion callback is called.
*
* Application normally wants to attach it's specific data in the
* \c user_data field so that it can keep track of which operation has
* completed when the callback is called. Alternatively, application can
* also extend this struct to include its data, because the pointer that
* is returned in the completion callback will be exactly the same as
* the pointer supplied when the asynchronous function is called.
*/
typedef struct pj_ioqueue_op_key_t
{
void *internal__[32]; /**< Internal I/O Queue data. */
void *activesock_data; /**< Active socket data. */
void *user_data; /**< Application data. */
} pj_ioqueue_op_key_t;
/**
* This structure describes the callbacks to be called when I/O operation
* completes.
*/
typedef struct pj_ioqueue_callback
{
/**
* This callback is called when #pj_ioqueue_recv or #pj_ioqueue_recvfrom
* completes.
*
* @param key The key.
* @param op_key Operation key.
* @param bytes_read >= 0 to indicate the amount of data read,
* otherwise negative value containing the error
* code. To obtain the pj_status_t error code, use
* (pj_status_t code = -bytes_read).
*/
void (*on_read_complete)(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_read);
/**
* This callback is called when #pj_ioqueue_send or #pj_ioqueue_sendto
* completes.
*
* @param key The key.
* @param op_key Operation key.
* @param bytes_sent >= 0 to indicate the amount of data written,
* otherwise negative value containing the error
* code. To obtain the pj_status_t error code, use
* (pj_status_t code = -bytes_sent).
*/
void (*on_write_complete)(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_sent);
/**
* This callback is called when #pj_ioqueue_accept completes.
*
* @param key The key.
* @param op_key Operation key.
* @param sock Newly connected socket.
* @param status Zero if the operation completes successfully.
*/
void (*on_accept_complete)(pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_sock_t sock,
pj_status_t status);
/**
* This callback is called when #pj_ioqueue_connect completes.
*
* @param key The key.
* @param status PJ_SUCCESS if the operation completes successfully.
*/
void (*on_connect_complete)(pj_ioqueue_key_t *key,
pj_status_t status);
} pj_ioqueue_callback;
/**
* Types of pending I/O Queue operation. This enumeration is only used
* internally within the ioqueue.
*/
typedef enum pj_ioqueue_operation_e
{
PJ_IOQUEUE_OP_NONE = 0, /**< No operation. */
PJ_IOQUEUE_OP_READ = 1, /**< read() operation. */
PJ_IOQUEUE_OP_RECV = 2, /**< recv() operation. */
PJ_IOQUEUE_OP_RECV_FROM = 4, /**< recvfrom() operation. */
PJ_IOQUEUE_OP_WRITE = 8, /**< write() operation. */
PJ_IOQUEUE_OP_SEND = 16, /**< send() operation. */
PJ_IOQUEUE_OP_SEND_TO = 32, /**< sendto() operation. */
#if defined(PJ_HAS_TCP) && PJ_HAS_TCP != 0
PJ_IOQUEUE_OP_ACCEPT = 64, /**< accept() operation. */
PJ_IOQUEUE_OP_CONNECT = 128 /**< connect() operation. */
#endif /* PJ_HAS_TCP */
} pj_ioqueue_operation_e;
/**
* This macro specifies the maximum number of events that can be
* processed by the ioqueue on a single poll cycle, on implementation
* that supports it. The value is only meaningfull when specified
* during PJLIB build.
*/
#ifndef PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL
# define PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL (16)
#endif
/**
* This macro specifies the maximum event candidates collected by each
* polling thread to be able to reach maximum number of processed events
* (i.e: PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL) in each poll cycle.
* An event candidate will be dispatched to application as event unless
* it is already being dispatched by other polling thread. So in order to
* anticipate such race condition, each poll operation should collects its
* event candidates more than PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL, the
* recommended value is (PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL *
* number of polling threads).
*
* The value is only meaningfull when specified during PJLIB build and
* is only effective on multiple polling threads environment.
*/
#if !defined(PJ_IOQUEUE_MAX_CAND_EVENTS) || \
PJ_IOQUEUE_MAX_CAND_EVENTS < PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL
# undef PJ_IOQUEUE_MAX_CAND_EVENTS
# define PJ_IOQUEUE_MAX_CAND_EVENTS PJ_IOQUEUE_MAX_EVENTS_IN_SINGLE_POLL
#endif
/**
* When this flag is specified in ioqueue's recv() or send() operations,
* the ioqueue will always mark the operation as asynchronous.
*/
#define PJ_IOQUEUE_ALWAYS_ASYNC ((pj_uint32_t)1 << (pj_uint32_t)31)
/**
* Epoll flags.
*/
typedef enum pj_ioqueue_epoll_flag
{
/** Use of EPOLLEXCLUSIVE.
*/
PJ_IOQUEUE_EPOLL_EXCLUSIVE = 1,
/** Use of EPOLLONESHOT.
*/
PJ_IOQUEUE_EPOLL_ONESHOT = 2,
/**
* Default flag to specify which epoll type to use, which mean to use
* EPOLLEXCLUSIVE if available, otherwise EPOLLONESHOT, otherwise "bare"
* epoll when neither are available.
*/
PJ_IOQUEUE_EPOLL_AUTO = PJ_IOQUEUE_EPOLL_EXCLUSIVE |
PJ_IOQUEUE_EPOLL_ONESHOT,
} pj_ioqueue_epoll_flag;
/**
* Additional settings that can be given during ioqueue creation. Application
* MUST initialize this structure with #pj_ioqueue_cfg_default().
*/
typedef struct pj_ioqueue_cfg
{
/**
* Specify flags to control e.g. how events are handled when epoll backend
* is used on Linux. The values are combination of pj_ioqueue_epoll_flag.
* The default value is PJ_IOQUEUE_DEFAULT_EPOLL_FLAGS, which by default
* is set to PJ_IOQUEUE_EPOLL_AUTO. This setting will be ignored for other
* ioqueue backends.
*/
unsigned epoll_flags;
/**
* Default concurrency for the handles registered to this ioqueue. Setting
* this to non-zero enables a handle to process more than one operations
* at the same time using different threads. Default is
* PJ_IOQUEUE_DEFAULT_ALLOW_CONCURRENCY. This setting is equivalent to
* calling pj_ioqueue_set_default_concurrency() after creating the ioqueue.
*/
pj_bool_t default_concurrency;
} pj_ioqueue_cfg;
/**
* Initialize the ioqueue configuration with the default values.
*
* @param cfg The configuration to be initialized.
*/
PJ_DECL(void) pj_ioqueue_cfg_default(pj_ioqueue_cfg *cfg);
/**
* Return the name of the ioqueue implementation.
*
* @return Implementation name.
*/
PJ_DECL(const char*) pj_ioqueue_name(void);
/**
* Create a new I/O Queue framework.
*
* @param pool The pool to allocate the I/O queue structure.
* @param max_fd The maximum number of handles to be supported, which
* should not exceed PJ_IOQUEUE_MAX_HANDLES.
* @param ioqueue Pointer to hold the newly created I/O Queue.
*
* @return PJ_SUCCESS on success.
*/
PJ_DECL(pj_status_t) pj_ioqueue_create( pj_pool_t *pool,
pj_size_t max_fd,
pj_ioqueue_t **ioqueue);
/**
* Create a new I/O Queue framework.
*
* @param pool The pool to allocate the I/O queue structure.
* @param max_fd The maximum number of handles to be supported, which
* should not exceed PJ_IOQUEUE_MAX_HANDLES.
* @param cfg Optional ioqueue configuration. Application must
* initialize this structure with pj_ioqueue_cfg_default()
* first. If this is not specified, default config values
* as set pj_ioqueue_cfg_default() by will be used.
* @param ioqueue Pointer to hold the newly created I/O Queue.
*
* @return PJ_SUCCESS on success.
*/
PJ_DECL(pj_status_t) pj_ioqueue_create2( pj_pool_t *pool,
pj_size_t max_fd,
const pj_ioqueue_cfg *cfg,
pj_ioqueue_t **ioqueue);
/**
* Destroy the I/O queue.
*
* @param ioque The I/O Queue to be destroyed.
*
* @return PJ_SUCCESS if success.
*/
PJ_DECL(pj_status_t) pj_ioqueue_destroy( pj_ioqueue_t *ioque );
/**
* Set the lock object to be used by the I/O Queue. This function can only
* be called right after the I/O queue is created, before any handle is
* registered to the I/O queue.
*
* Initially the I/O queue is created with non-recursive mutex protection.
* Applications can supply alternative lock to be used by calling this
* function.
*
* @param ioque The ioqueue instance.
* @param lock The lock to be used by the ioqueue.
* @param auto_delete In non-zero, the lock will be deleted by the ioqueue.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_set_lock( pj_ioqueue_t *ioque,
pj_lock_t *lock,
pj_bool_t auto_delete );
/**
* Set default concurrency policy for this ioqueue. If this function is not
* called, the default concurrency policy for the ioqueue is controlled by
* compile time setting PJ_IOQUEUE_DEFAULT_ALLOW_CONCURRENCY.
*
* Note that changing the concurrency setting to the ioqueue will only affect
* subsequent key registrations. To modify the concurrency setting for
* individual key, use #pj_ioqueue_set_concurrency().
*
* @param ioqueue The ioqueue instance.
* @param allow Non-zero to allow concurrent callback calls, or
* PJ_FALSE to disallow it.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_set_default_concurrency(pj_ioqueue_t *ioqueue,
pj_bool_t allow);
/**
* Register a socket to the I/O queue framework.
* When a socket is registered to the IOQueue, it may be modified to use
* non-blocking IO. If it is modified, there is no guarantee that this
* modification will be restored after the socket is unregistered.
*
* @param pool To allocate the resource for the specified handle,
* which must be valid until the handle/key is unregistered
* from I/O Queue.
* @param ioque The I/O Queue.
* @param sock The socket.
* @param user_data User data to be associated with the key, which can be
* retrieved later.
* @param cb Callback to be called when I/O operation completes.
* @param key Pointer to receive the key to be associated with this
* socket. Subsequent I/O queue operation will need this
* key.
*
* @return PJ_SUCCESS on success, or the error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_register_sock( pj_pool_t *pool,
pj_ioqueue_t *ioque,
pj_sock_t sock,
void *user_data,
const pj_ioqueue_callback *cb,
pj_ioqueue_key_t **key );
/**
* Variant of pj_ioqueue_register_sock() with additional group lock parameter.
* If group lock is set for the key, the key will add the reference counter
* when the socket is registered and decrease it when it is destroyed.
*/
PJ_DECL(pj_status_t) pj_ioqueue_register_sock2(pj_pool_t *pool,
pj_ioqueue_t *ioque,
pj_sock_t sock,
pj_grp_lock_t *grp_lock,
void *user_data,
const pj_ioqueue_callback *cb,
pj_ioqueue_key_t **key );
/**
* Unregister from the I/O Queue framework. Caller must make sure that
* the key doesn't have any pending operations before calling this function,
* by calling #pj_ioqueue_is_pending() for all previously submitted
* operations except asynchronous connect, and if necessary call
* #pj_ioqueue_post_completion() to cancel the pending operations.
*
* Note that asynchronous connect operation will automatically be
* cancelled during the unregistration.
*
* Also note that when I/O Completion Port backend is used, application
* MUST close the handle immediately after unregistering the key. This is
* because there is no unregistering API for IOCP. The only way to
* unregister the handle from IOCP is to close the handle.
*
* @param key The key that was previously obtained from registration.
*
* @return PJ_SUCCESS on success or the error code.
*
* @see pj_ioqueue_is_pending
*/
PJ_DECL(pj_status_t) pj_ioqueue_unregister( pj_ioqueue_key_t *key );
/**
* Get user data associated with an ioqueue key.
*
* @param key The key that was previously obtained from registration.
*
* @return The user data associated with the descriptor, or NULL
* on error or if no data is associated with the key during
* registration.
*/
PJ_DECL(void*) pj_ioqueue_get_user_data( pj_ioqueue_key_t *key );
/**
* Set or change the user data to be associated with the file descriptor or
* handle or socket descriptor.
*
* @param key The key that was previously obtained from registration.
* @param user_data User data to be associated with the descriptor.
* @param old_data Optional parameter to retrieve the old user data.
*
* @return PJ_SUCCESS on success or the error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_set_user_data( pj_ioqueue_key_t *key,
void *user_data,
void **old_data);
/**
* Configure whether the ioqueue is allowed to call the key's callback
* concurrently/in parallel. The default concurrency setting for the key
* is controlled by ioqueue's default concurrency value, which can be
* changed by calling #pj_ioqueue_set_default_concurrency().
*
* If concurrency is allowed for the key, it means that if there are more
* than one pending operations complete simultaneously, more than one
* threads may call the key's callback at the same time. This generally
* would promote good scalability for application, at the expense of more
* complexity to manage the concurrent accesses in application's code.
*
* Alternatively application may disable the concurrent access by
* setting the \a allow flag to false. With concurrency disabled, only
* one thread can call the key's callback at one time.
*
* @param key The key that was previously obtained from registration.
* @param allow Set this to non-zero to allow concurrent callback calls
* and zero (PJ_FALSE) to disallow it.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_set_concurrency(pj_ioqueue_key_t *key,
pj_bool_t allow);
/**
* Acquire the key's mutex. When the key's concurrency is disabled,
* application may call this function to synchronize its operation
* with the key's callback (i.e. this function will block until the
* key's callback returns).
*
* @param key The key that was previously obtained from registration.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_lock_key(pj_ioqueue_key_t *key);
/**
* Try to acquire the key's mutex. When the key's concurrency is disabled,
* application may call this function to synchronize its operation
* with the key's callback.
*
* @param key The key that was previously obtained from registration.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_trylock_key(pj_ioqueue_key_t *key);
/**
* Release the lock previously acquired with pj_ioqueue_lock_key().
*
* @param key The key that was previously obtained from registration.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_unlock_key(pj_ioqueue_key_t *key);
/**
* Initialize operation key.
*
* @param op_key The operation key to be initialied.
* @param size The size of the operation key.
*/
PJ_DECL(void) pj_ioqueue_op_key_init( pj_ioqueue_op_key_t *op_key,
pj_size_t size );
/**
* Check if operation is pending on the specified operation key.
* The \c op_key must have been initialized with #pj_ioqueue_op_key_init()
* or submitted as pending operation before, or otherwise the result
* is undefined.
*
* @param key The key.
* @param op_key The operation key, previously submitted to any of
* the I/O functions and has returned PJ_EPENDING.
*
* @return Non-zero if operation is still pending.
*/
PJ_DECL(pj_bool_t) pj_ioqueue_is_pending( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key );
/**
* Post completion status to the specified operation key and call the
* appropriate callback. When the callback is called, the number of bytes
* received in read/write callback or the status in accept/connect callback
* will be set from the \c bytes_status parameter.
*
* @param key The key.
* @param op_key Pending operation key.
* @param bytes_status Number of bytes or status to be set. A good value
* to put here is -PJ_ECANCELLED.
*
* @return PJ_SUCCESS if completion status has been successfully
* sent.
*/
PJ_DECL(pj_status_t) pj_ioqueue_post_completion( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_ssize_t bytes_status );
/**
* Clear ioqueue key states. This function will cancel any outstanding
* operations on that key, without invoking any completion callback.
* After calling this function, application should reinit its all operation
* keys, i.e: using pj_ioqueue_op_key_init(), before reusing them.
*
* @param key The key.
*
* @return PJ_SUCCESS on success or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_clear_key( pj_ioqueue_key_t *key );
#if defined(PJ_HAS_TCP) && PJ_HAS_TCP != 0
/**
* Instruct I/O Queue to accept incoming connection on the specified
* listening socket. This function will return immediately (i.e. non-blocking)
* regardless whether a connection is immediately available. If the function
* can't complete immediately, the caller will be notified about the incoming
* connection when it calls pj_ioqueue_poll(). If a new connection is
* immediately available, the function returns PJ_SUCCESS with the new
* connection; in this case, the callback WILL NOT be called.
*
* @param key The key which registered to the server socket.
* @param op_key An operation specific key to be associated with the
* pending operation, so that application can keep track of
* which operation has been completed when the callback is
* called.
* @param new_sock Argument which contain pointer to receive the new socket
* for the incoming connection.
* @param local Optional argument which contain pointer to variable to
* receive local address.
* @param remote Optional argument which contain pointer to variable to
* receive the remote address.
* @param addrlen On input, contains the length of the buffer for the
* address, and on output, contains the actual length of the
* address. This argument is optional.
* @return
* - PJ_SUCCESS When connection is available immediately, and the
* parameters will be updated to contain information about
* the new connection. In this case, a completion callback
* WILL NOT be called.
* - PJ_EPENDING If no connection is available immediately. When a new
* connection arrives, the callback will be called.
* - non-zero which indicates the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_accept( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
pj_sock_t *new_sock,
pj_sockaddr_t *local,
pj_sockaddr_t *remote,
int *addrlen );
/**
* Initiate non-blocking socket connect. If the socket can NOT be connected
* immediately, asynchronous connect() will be scheduled and caller will be
* notified via completion callback when it calls pj_ioqueue_poll(). If
* socket is connected immediately, the function returns PJ_SUCCESS and
* completion callback WILL NOT be called.
*
* @param key The key associated with TCP socket
* @param addr The remote address.
* @param addrlen The remote address length.
*
* @return
* - PJ_SUCCESS If socket is connected immediately. In this case, the
* completion callback WILL NOT be called.
* - PJ_EPENDING If operation is queued, or
* - non-zero Indicates the error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_connect( pj_ioqueue_key_t *key,
const pj_sockaddr_t *addr,
int addrlen );
#endif /* PJ_HAS_TCP */
/**
* Poll the I/O Queue for completed events.
*
* Note: polling the ioqueue is not necessary in Symbian. Please see
* @ref PJ_SYMBIAN_OS for more info.
*
* @param ioque the I/O Queue.
* @param timeout polling timeout, or NULL if the thread wishes to wait
* indefinetely for the event.
*
* @return
* - zero if timed out (no event).
* - (<0) if error occured during polling. Callback will NOT be called.
* - (>1) to indicate numbers of events. Callbacks have been called.
*/
PJ_DECL(int) pj_ioqueue_poll( pj_ioqueue_t *ioque,
const pj_time_val *timeout);
/**
* Instruct the I/O Queue to read from the specified handle. This function
* returns immediately (i.e. non-blocking) regardless whether some data has
* been transferred. If the operation can't complete immediately, caller will
* be notified about the completion when it calls pj_ioqueue_poll(). If data
* is immediately available, the function will return PJ_SUCCESS and the
* callback WILL NOT be called.
*
* @param key The key that uniquely identifies the handle.
* @param op_key An operation specific key to be associated with the
* pending operation, so that application can keep track of
* which operation has been completed when the callback is
* called. Caller must make sure that this key remains
* valid until the function completes.
* @param buffer The buffer to hold the read data. The caller MUST make sure
* that this buffer remain valid until the framework completes
* reading the handle.
* @param length On input, it specifies the size of the buffer. If data is
* available to be read immediately, the function returns
* PJ_SUCCESS and this argument will be filled with the
* amount of data read. If the function is pending, caller
* will be notified about the amount of data read in the
* callback. This parameter can point to local variable in
* caller's stack and doesn't have to remain valid for the
* duration of pending operation.
* @param flags Recv flag. If flags has PJ_IOQUEUE_ALWAYS_ASYNC then
* the function will never return PJ_SUCCESS.
*
* @return
* - PJ_SUCCESS If immediate data has been received in the buffer. In this
* case, the callback WILL NOT be called.
* - PJ_EPENDING If the operation has been queued, and the callback will be
* called when data has been received.
* - non-zero The return value indicates the error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_recv( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
void *buffer,
pj_ssize_t *length,
pj_uint32_t flags );
/**
* This function behaves similarly as #pj_ioqueue_recv(), except that it is
* normally called for socket, and the remote address will also be returned
* along with the data. Caller MUST make sure that both buffer and addr
* remain valid until the framework completes reading the data.
*
* @param key The key that uniquely identifies the handle.
* @param op_key An operation specific key to be associated with the
* pending operation, so that application can keep track of
* which operation has been completed when the callback is
* called.
* @param buffer The buffer to hold the read data. The caller MUST make sure
* that this buffer remain valid until the framework completes
* reading the handle.
* @param length On input, it specifies the size of the buffer. If data is
* available to be read immediately, the function returns
* PJ_SUCCESS and this argument will be filled with the
* amount of data read. If the function is pending, caller
* will be notified about the amount of data read in the
* callback. This parameter can point to local variable in
* caller's stack and doesn't have to remain valid for the
* duration of pending operation.
* @param flags Recv flag. If flags has PJ_IOQUEUE_ALWAYS_ASYNC then
* the function will never return PJ_SUCCESS.
* @param addr Optional Pointer to buffer to receive the address.
* @param addrlen On input, specifies the length of the address buffer.
* On output, it will be filled with the actual length of
* the address. This argument can be NULL if \c addr is not
* specified.
*
* @return
* - PJ_SUCCESS If immediate data has been received. In this case, the
* callback must have been called before this function
* returns, and no pending operation is scheduled.
* - PJ_EPENDING If the operation has been queued.
* - non-zero The return value indicates the error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_recvfrom( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
void *buffer,
pj_ssize_t *length,
pj_uint32_t flags,
pj_sockaddr_t *addr,
int *addrlen);
/**
* Instruct the I/O Queue to write to the handle. This function will return
* immediately (i.e. non-blocking) regardless whether some data has been
* transferred. If the function can't complete immediately, the caller will
* be notified about the completion when it calls pj_ioqueue_poll(). If
* operation completes immediately and data has been transferred, the function
* returns PJ_SUCCESS and the callback will NOT be called.
*
* @param key The key that identifies the handle.
* @param op_key An operation specific key to be associated with the
* pending operation, so that application can keep track of
* which operation has been completed when the callback is
* called.
* @param data The data to send. Caller MUST make sure that this buffer
* remains valid until the write operation completes.
* @param length On input, it specifies the length of data to send. When
* data was sent immediately, this function returns PJ_SUCCESS
* and this parameter contains the length of data sent. If
* data can not be sent immediately, an asynchronous operation
* is scheduled and caller will be notified via callback the
* number of bytes sent. This parameter can point to local
* variable on caller's stack and doesn't have to remain
* valid until the operation has completed.
* @param flags Send flags. If flags has PJ_IOQUEUE_ALWAYS_ASYNC then
* the function will never return PJ_SUCCESS.
*
* @return
* - PJ_SUCCESS If data was immediately transferred. In this case, no
* pending operation has been scheduled and the callback
* WILL NOT be called.
* - PJ_EPENDING If the operation has been queued. Once data base been
* transferred, the callback will be called.
* - non-zero The return value indicates the error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_send( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
const void *data,
pj_ssize_t *length,
pj_uint32_t flags );
/**
* Instruct the I/O Queue to write to the handle. This function will return
* immediately (i.e. non-blocking) regardless whether some data has been
* transferred. If the function can't complete immediately, the caller will
* be notified about the completion when it calls pj_ioqueue_poll(). If
* operation completes immediately and data has been transferred, the function
* returns PJ_SUCCESS and the callback will NOT be called.
*
* @param key the key that identifies the handle.
* @param op_key An operation specific key to be associated with the
* pending operation, so that application can keep track of
* which operation has been completed when the callback is
* called.
* @param data the data to send. Caller MUST make sure that this buffer
* remains valid until the write operation completes.
* @param length On input, it specifies the length of data to send. When
* data was sent immediately, this function returns PJ_SUCCESS
* and this parameter contains the length of data sent. If
* data can not be sent immediately, an asynchronous operation
* is scheduled and caller will be notified via callback the
* number of bytes sent. This parameter can point to local
* variable on caller's stack and doesn't have to remain
* valid until the operation has completed.
* @param flags send flags. If flags has PJ_IOQUEUE_ALWAYS_ASYNC then
* the function will never return PJ_SUCCESS.
* @param addr Optional remote address.
* @param addrlen Remote address length, \c addr is specified.
*
* @return
* - PJ_SUCCESS If data was immediately written.
* - PJ_EPENDING If the operation has been queued.
* - non-zero The return value indicates the error code.
*/
PJ_DECL(pj_status_t) pj_ioqueue_sendto( pj_ioqueue_key_t *key,
pj_ioqueue_op_key_t *op_key,
const void *data,
pj_ssize_t *length,
pj_uint32_t flags,
const pj_sockaddr_t *addr,
int addrlen);
/**
* Get the underlying OS handle associated with an ioqueue instance.
*
* @param ioqueue The ioqueue instance.
*
* @return The OS handle associated with the instance.
* For epoll/kqueue this will be a pointer to the file
* descriptor. For all other platforms, this will be a pointer
* to a platform-specific handle.
* If no handle is available, NULL will be returned.
*/
PJ_DECL(pj_oshandle_t) pj_ioqueue_get_os_handle( pj_ioqueue_t *ioqueue );
/**
* @}
*/
PJ_END_DECL
#endif /* __PJ_IOQUEUE_H__ */

152
GSMGateway/app/src/main/cpp/pj/ip_helper.h Normal file
View File

@@ -0,0 +1,152 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_IP_ROUTE_H__
#define __PJ_IP_ROUTE_H__
/**
* @file ip_helper.h
* @brief IP helper API
*/
#include <pj/sock.h>
#include <pj/string.h>
PJ_BEGIN_DECL
/**
* @defgroup pj_ip_helper IP Interface and Routing Helper
* @ingroup PJ_IO
* @{
*
* This module provides functions to query local host's IP interface and
* routing table.
*/
/**
* This structure describes IP routing entry.
*/
typedef union pj_ip_route_entry
{
/** IP routing entry for IP version 4 routing */
struct
{
pj_in_addr if_addr; /**< Local interface IP address. */
pj_in_addr dst_addr; /**< Destination IP address. */
pj_in_addr mask; /**< Destination mask. */
} ipv4;
} pj_ip_route_entry;
/**
* This structure describes options for pj_enum_ip_interface2().
*/
typedef struct pj_enum_ip_option
{
/**
* Family of the address to be retrieved. Application may specify
* pj_AF_UNSPEC() to retrieve all addresses, or pj_AF_INET() or
* pj_AF_INET6() to retrieve interfaces with specific address family.
*
* Default: pj_AF_UNSPEC().
*/
int af;
/**
* IPv6 addresses can have a DEPRECATED flag, if this flag is set, any
* DEPRECATED IPv6 address will be omitted. Currently this is only
* available for Linux, on other platforms, if this flag is set,
* pj_enum_ip_interface2() will return PJ_ENOTSUP.
*
* Default: PJ_FALSE.
*/
pj_bool_t omit_deprecated_ipv6;
} pj_enum_ip_option;
/**
* Get default values of IP enumeration option.
*
* @param opt The IP enumeration option.
*/
PJ_INLINE(void) pj_enum_ip_option_default(pj_enum_ip_option *opt)
{
pj_bzero(opt, sizeof(*opt));
}
/**
* Enumerate the local IP interfaces currently active in the host.
*
* @param af Family of the address to be retrieved. Application
* may specify pj_AF_UNSPEC() to retrieve all addresses,
* or pj_AF_INET() or pj_AF_INET6() to retrieve interfaces
* with specific address family.
* @param count On input, specify the number of entries. On output,
* it will be filled with the actual number of entries.
* @param ifs Array of socket addresses, which address part will
* be filled with the interface address. The address
* family part will be initialized with the address
* family of the IP address.
*
* @return PJ_SUCCESS on success, or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_enum_ip_interface(int af,
unsigned *count,
pj_sockaddr ifs[]);
/**
* Enumerate the local IP interfaces currently active in the host with
* capability to filter DEPRECATED IPv6 addresses (currently only for Linux).
*
* @param opt The option, default option will be used if NULL.
* @param count On input, specify the number of entries. On output,
* it will be filled with the actual number of entries.
* @param ifs Array of socket (with flags) addresses, which address part
* will be filled with the interface address. The address
* family part will be initialized with the address
* family of the IP address.
*
* @return PJ_SUCCESS on success, or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_enum_ip_interface2(const pj_enum_ip_option *opt,
unsigned *count,
pj_sockaddr ifs[]);
/**
* Enumerate the IP routing table for this host.
*
* @param count On input, specify the number of routes entries. On output,
* it will be filled with the actual number of route entries.
* @param routes Array of IP routing entries.
*
* @return PJ_SUCCESS on success, or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_enum_ip_route(unsigned *count,
pj_ip_route_entry routes[]);
/** @} */
PJ_END_DECL
#endif /* __PJ_IP_ROUTE_H__ */

57
GSMGateway/app/src/main/cpp/pj/limits.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* Copyright (C) 2017 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2017 George Joseph <gjoseph@digium.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_LIMITS_H__
#define __PJ_LIMITS_H__
/**
* @file limits.h
* @brief Common min and max values
*/
#include <pj/compat/limits.h>
/** Maximum value for signed 32-bit integer. */
#define PJ_MAXINT32 0x7fffffff
/** Minimum value for signed 32-bit integer. */
#define PJ_MININT32 0x80000000
/** Maximum value for unsigned 16-bit integer. */
#define PJ_MAXUINT16 0xffff
/** Maximum value for unsigned char. */
#define PJ_MAXUINT8 0xff
/** Maximum value for long. */
#define PJ_MAXLONG LONG_MAX
/** Minimum value for long. */
#define PJ_MINLONG LONG_MIN
/** Minimum value for unsigned long. */
#define PJ_MAXULONG ULONG_MAX
/** Maximum value for generic unsigned integer. */
#if defined(PJ_HAS_INT64) && PJ_HAS_INT64!=0
# define PJ_MAXUINT 0xffffffffffffffffULL
#else
# define PJ_MAXUINT 0xffffffff
#endif
#endif /* __PJ_LIMITS_H__ */

268
GSMGateway/app/src/main/cpp/pj/list.h Normal file
View File

@@ -0,0 +1,268 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_LIST_H__
#define __PJ_LIST_H__
/**
* @file list.h
* @brief Linked List data structure.
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/*
* @defgroup PJ_DS Data Structure.
*/
/**
* @defgroup PJ_LIST Linked List
* @ingroup PJ_DS
* @{
*
* List in PJLIB is implemented as doubly-linked list, and it won't require
* dynamic memory allocation (just as all PJLIB data structures). The list here
* should be viewed more like a low level C list instead of high level C++ list
* (which normally are easier to use but require dynamic memory allocations),
* therefore all caveats with C list apply here too (such as you can NOT put
* a node in more than one lists).
*
* \section pj_list_example_sec Examples
*
* See below for examples on how to manipulate linked list:
* - List sample: \src{pjlib/src/pjlib-samples/list.c}
* - List test: \src{pjlib/src/pjlib-test/list.c}
*/
/**
* Use this macro in the start of the structure declaration to declare that
* the structure can be used in the linked list operation. This macro simply
* declares additional member @a prev and @a next to the structure.
* @hideinitializer
*/
#define PJ_DECL_LIST_MEMBER(type) \
/** List @a prev. */ \
type *prev; \
/** List @a next. */ \
type *next
/**
* This structure describes generic list node and list. The owner of this list
* must initialize the 'value' member to an appropriate value (typically the
* owner itself).
*/
struct pj_list
{
PJ_DECL_LIST_MEMBER(void);
} PJ_ATTR_MAY_ALIAS; /* may_alias avoids warning with gcc-4.4 -Wall -O2 */
/**
* Initialize the list.
* Initially, the list will have no member, and function pj_list_empty() will
* always return nonzero (which indicates TRUE) for the newly initialized
* list.
*
* @param node The list head.
*/
PJ_INLINE(void) pj_list_init(pj_list_type * node)
{
((pj_list*)node)->next = ((pj_list*)node)->prev = node;
}
/**
* Check that the list is empty.
*
* @param node The list head.
*
* @return Non-zero if the list is empty, or zero if it is not empty.
*
*/
PJ_INLINE(int) pj_list_empty(const pj_list_type * node)
{
return ((pj_list*)node)->next == node;
}
/**
* Insert the node to the list before the specified element position.
*
* @param pos The element to which the node will be inserted before.
* @param node The element to be inserted.
*
*/
PJ_IDECL(void) pj_list_insert_before(pj_list_type *pos, pj_list_type *node);
/**
* Insert the node to the back of the list. This is just an alias for
* #pj_list_insert_before().
*
* @param list The list.
* @param node The element to be inserted.
*/
PJ_INLINE(void) pj_list_push_back(pj_list_type *list, pj_list_type *node)
{
pj_list_insert_before(list, node);
}
/**
* Inserts all nodes in \a nodes to the target list.
*
* @param lst The target list.
* @param nodes Nodes list.
*/
PJ_IDECL(void) pj_list_insert_nodes_before(pj_list_type *lst,
pj_list_type *nodes);
/**
* Insert a node to the list after the specified element position.
*
* @param pos The element in the list which will precede the inserted
* element.
* @param node The element to be inserted after the position element.
*
*/
PJ_IDECL(void) pj_list_insert_after(pj_list_type *pos, pj_list_type *node);
/**
* Insert the node to the front of the list. This is just an alias for
* #pj_list_insert_after().
*
* @param list The list.
* @param node The element to be inserted.
*/
PJ_INLINE(void) pj_list_push_front(pj_list_type *list, pj_list_type *node)
{
pj_list_insert_after(list, node);
}
/**
* Insert all nodes in \a nodes to the target list.
*
* @param lst The target list.
* @param nodes Nodes list.
*/
PJ_IDECL(void) pj_list_insert_nodes_after(pj_list_type *lst,
pj_list_type *nodes);
/**
* Remove elements from the source list, and insert them to the destination
* list. The elements of the source list will occupy the
* front elements of the target list. Note that the node pointed by \a list2
* itself is not considered as a node, but rather as the list descriptor, so
* it will not be inserted to the \a list1. The elements to be inserted starts
* at \a list2->next. If \a list2 is to be included in the operation, use
* \a pj_list_insert_nodes_before.
*
* @param list1 The destination list.
* @param list2 The source list.
*
*/
PJ_IDECL(void) pj_list_merge_first(pj_list_type *list1, pj_list_type *list2);
/**
* Remove elements from the second list argument, and insert them to the list
* in the first argument. The elements from the second list will be appended
* to the first list. Note that the node pointed by \a list2
* itself is not considered as a node, but rather as the list descriptor, so
* it will not be inserted to the \a list1. The elements to be inserted starts
* at \a list2->next. If \a list2 is to be included in the operation, use
* \a pj_list_insert_nodes_before.
*
* @param list1 The element in the list which will precede the inserted
* element.
* @param list2 The element in the list to be inserted.
*
*/
PJ_IDECL(void) pj_list_merge_last( pj_list_type *list1, pj_list_type *list2);
/**
* Erase the node from the list it currently belongs.
*
* @param node The element to be erased.
*/
PJ_IDECL(void) pj_list_erase(pj_list_type *node);
/**
* Find node in the list.
*
* @param list The list head.
* @param node The node element to be searched.
*
* @return The node itself if it is found in the list, or NULL if it is not
* found in the list.
*/
PJ_IDECL(pj_list_type*) pj_list_find_node(pj_list_type *list,
pj_list_type *node);
/**
* Search the list for the specified value, using the specified comparison
* function. This function iterates on nodes in the list, started with the
* first node, and call the user supplied comparison function until the
* comparison function returns ZERO.
*
* @param list The list head.
* @param value The user defined value to be passed in the comparison
* function
* @param comp The comparison function, which should return ZERO to
* indicate that the searched value is found.
*
* @return The first node that matched, or NULL if it is not found.
*/
PJ_IDECL(pj_list_type*) pj_list_search(pj_list_type *list, void *value,
int (*comp)(void *value,
const pj_list_type *node)
);
/**
* Traverse the list to get the number of elements in the list.
*
* @param list The list head.
*
* @return Number of elements.
*/
PJ_IDECL(pj_size_t) pj_list_size(const pj_list_type *list);
/**
* @}
*/
#if PJ_FUNCTIONS_ARE_INLINED
# include "list_i.h"
#endif
PJ_END_DECL
#endif /* __PJ_LIST_H__ */

120
GSMGateway/app/src/main/cpp/pj/list_i.h Normal file
View File

@@ -0,0 +1,120 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/* Internal */
PJ_INLINE(void) pj_link_node(pj_list_type *prev, pj_list_type *next)
{
((pj_list*)prev)->next = next;
((pj_list*)next)->prev = prev;
}
PJ_IDEF(void) pj_list_insert_after(pj_list_type *pos, pj_list_type *node)
{
((pj_list*)node)->prev = pos;
((pj_list*)node)->next = ((pj_list*)pos)->next;
((pj_list*) ((pj_list*)pos)->next) ->prev = node;
((pj_list*)pos)->next = node;
}
PJ_IDEF(void) pj_list_insert_before(pj_list_type *pos, pj_list_type *node)
{
pj_list_insert_after(((pj_list*)pos)->prev, node);
}
PJ_IDEF(void) pj_list_insert_nodes_after(pj_list_type *pos, pj_list_type *lst)
{
pj_list *lst_last = (pj_list *) ((pj_list*)lst)->prev;
pj_list *pos_next = (pj_list *) ((pj_list*)pos)->next;
pj_link_node(pos, lst);
pj_link_node(lst_last, pos_next);
}
PJ_IDEF(void) pj_list_insert_nodes_before(pj_list_type *pos, pj_list_type *lst)
{
pj_list_insert_nodes_after(((pj_list*)pos)->prev, lst);
}
PJ_IDEF(void) pj_list_merge_last(pj_list_type *lst1, pj_list_type *lst2)
{
if (!pj_list_empty(lst2)) {
pj_link_node(((pj_list*)lst1)->prev, ((pj_list*)lst2)->next);
pj_link_node(((pj_list*)lst2)->prev, lst1);
pj_list_init(lst2);
}
}
PJ_IDEF(void) pj_list_merge_first(pj_list_type *lst1, pj_list_type *lst2)
{
if (!pj_list_empty(lst2)) {
pj_link_node(((pj_list*)lst2)->prev, ((pj_list*)lst1)->next);
pj_link_node(((pj_list*)lst1), ((pj_list*)lst2)->next);
pj_list_init(lst2);
}
}
PJ_IDEF(void) pj_list_erase(pj_list_type *node)
{
pj_link_node( ((pj_list*)node)->prev, ((pj_list*)node)->next);
/* It'll be safer to init the next/prev fields to itself, to
* prevent multiple erase() from corrupting the list. See
* ticket #520 for one sample bug.
*/
pj_list_init(node);
}
PJ_IDEF(pj_list_type*) pj_list_find_node(pj_list_type *list, pj_list_type *node)
{
pj_list *p = (pj_list *) ((pj_list*)list)->next;
while (p != list && p != node)
p = (pj_list *) p->next;
return p==node ? p : NULL;
}
PJ_IDEF(pj_list_type*) pj_list_search(pj_list_type *list, void *value,
int (*comp)(void *value, const pj_list_type *node))
{
pj_list *p = (pj_list *) ((pj_list*)list)->next;
while (p != list && (*comp)(value, p) != 0)
p = (pj_list *) p->next;
return p==list ? NULL : p;
}
PJ_IDEF(pj_size_t) pj_list_size(const pj_list_type *list)
{
const pj_list *node = (const pj_list*) ((const pj_list*)list)->next;
pj_size_t count = 0;
while (node != list) {
++count;
node = (pj_list*)node->next;
}
return count;
}

453
GSMGateway/app/src/main/cpp/pj/lock.h Normal file
View File

@@ -0,0 +1,453 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_LOCK_H__
#define __PJ_LOCK_H__
/**
* @file lock.h
* @brief Higher abstraction for locking objects.
*/
#include <pj/types.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_LOCK Lock Objects
* @ingroup PJ_OS
* @{
*
* <b>Lock Objects</b> are higher abstraction for different lock mechanisms.
* It offers the same API for manipulating different lock types (e.g.
* @ref PJ_MUTEX "mutex", @ref PJ_SEM "semaphores", or null locks).
* Because Lock Objects have the same API for different types of lock
* implementation, it can be passed around in function arguments. As the
* result, it can be used to control locking policy for a particular
* feature.
*/
/**
* Create simple, non recursive mutex lock object.
*
* @param pool Memory pool.
* @param name Lock object's name.
* @param lock Pointer to store the returned handle.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_lock_create_simple_mutex( pj_pool_t *pool,
const char *name,
pj_lock_t **lock );
/**
* Create recursive mutex lock object.
*
* @param pool Memory pool.
* @param name Lock object's name.
* @param lock Pointer to store the returned handle.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_lock_create_recursive_mutex( pj_pool_t *pool,
const char *name,
pj_lock_t **lock );
/**
* Create NULL mutex. A NULL mutex doesn't actually have any synchronization
* object attached to it.
*
* @param pool Memory pool.
* @param name Lock object's name.
* @param lock Pointer to store the returned handle.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_lock_create_null_mutex( pj_pool_t *pool,
const char *name,
pj_lock_t **lock );
#if defined(PJ_HAS_SEMAPHORE) && PJ_HAS_SEMAPHORE != 0
/**
* Create semaphore lock object.
*
* @param pool Memory pool.
* @param name Lock object's name.
* @param initial Initial value of the semaphore.
* @param max Maximum value of the semaphore.
* @param lock Pointer to store the returned handle.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_lock_create_semaphore( pj_pool_t *pool,
const char *name,
unsigned initial,
unsigned max,
pj_lock_t **lock );
#endif /* PJ_HAS_SEMAPHORE */
/**
* Acquire lock on the specified lock object.
*
* @param lock The lock object.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_lock_acquire( pj_lock_t *lock );
/**
* Try to acquire lock on the specified lock object.
*
* @param lock The lock object.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_lock_tryacquire( pj_lock_t *lock );
/**
* Release lock on the specified lock object.
*
* @param lock The lock object.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_lock_release( pj_lock_t *lock );
/**
* Destroy the lock object.
*
* @param lock The lock object.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_lock_destroy( pj_lock_t *lock );
/** @} */
/**
* @defgroup PJ_GRP_LOCK Group Lock
* @ingroup PJ_LOCK
* @{
*
* Group lock is a synchronization object to manage concurrency among members
* within the same logical group. Example of such groups are:
*
* - dialog, which has members such as the dialog itself, an invite session,
* and several transactions
* - ICE, which has members such as ICE stream transport, ICE session, STUN
* socket, TURN socket, and down to ioqueue key
*
* Group lock has three functions:
*
* - mutual exclusion: to protect resources from being accessed by more than
* one threads at the same time
* - session management: to make sure that the resource is not destroyed
* while others are still using or about to use it.
* - lock coordinator: to provide uniform lock ordering among more than one
* lock objects, which is necessary to avoid deadlock.
*
* The requirements of the group lock are:
*
* - must satisfy all the functions above
* - must allow members to join or leave the group (for example,
* transaction may be added or removed from a dialog)
* - must be able to synchronize with external lock (for example, a dialog
* lock must be able to sync itself with PJSUA lock)
*
* Please see https://trac.pjsip.org/repos/wiki/Group_Lock for more info.
*/
/**
* Settings for creating the group lock.
*/
typedef struct pj_grp_lock_config
{
/**
* Creation flags, currently must be zero.
*/
unsigned flags;
} pj_grp_lock_config;
/**
* The group lock destroy handler, a destructor function called when
* a group lock is about to be destroyed.
*
* @param member A pointer to be passed to the handler.
*/
typedef void (*pj_grp_lock_handler)(void *member);
/**
* Initialize the config with the default values.
*
* @param cfg The config to be initialized.
*/
PJ_DECL(void) pj_grp_lock_config_default(pj_grp_lock_config *cfg);
/**
* Create a group lock object. Initially the group lock will have reference
* counter of zero.
*
* @param pool The group lock only uses the pool parameter to get
* the pool factory, from which it will create its own
* pool.
* @param cfg Optional configuration.
* @param p_grp_lock Pointer to receive the newly created group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_create(pj_pool_t *pool,
const pj_grp_lock_config *cfg,
pj_grp_lock_t **p_grp_lock);
/**
* Create a group lock object, with the specified destructor handler, to be
* called by the group lock when it is about to be destroyed. Initially the
* group lock will have reference counter of zero.
*
* @param pool The group lock only uses the pool parameter to get
* the pool factory, from which it will create its own
* pool.
* @param cfg Optional configuration.
* @param member A pointer to be passed to the handler.
* @param handler The destroy handler.
* @param p_grp_lock Pointer to receive the newly created group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_create_w_handler(pj_pool_t *pool,
const pj_grp_lock_config *cfg,
void *member,
pj_grp_lock_handler handler,
pj_grp_lock_t **p_grp_lock);
/**
* Forcibly destroy the group lock, ignoring the reference counter value.
*
* @param grp_lock The group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_destroy( pj_grp_lock_t *grp_lock);
/**
* Move the contents of the old lock to the new lock and destroy the
* old lock.
*
* @param old_lock The old group lock to be destroyed.
* @param new_lock The new group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_replace(pj_grp_lock_t *old_lock,
pj_grp_lock_t *new_lock);
/**
* Acquire lock on the specified group lock.
*
* @param grp_lock The group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_acquire( pj_grp_lock_t *grp_lock);
/**
* Acquire lock on the specified group lock if it is available, otherwise
* return immediately wihout waiting.
*
* @param grp_lock The group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_tryacquire( pj_grp_lock_t *grp_lock);
/**
* Release the previously held lock. This may cause the group lock
* to be destroyed if it is the last one to hold the reference counter.
* In that case, the function will return PJ_EGONE.
*
* @param grp_lock The group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_release( pj_grp_lock_t *grp_lock);
/**
* Add a destructor handler, to be called by the group lock when it is
* about to be destroyed.
*
* @param grp_lock The group lock.
* @param pool Pool to allocate memory for the handler.
* @param member A pointer to be passed to the handler.
* @param handler The destroy handler.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_add_handler(pj_grp_lock_t *grp_lock,
pj_pool_t *pool,
void *member,
pj_grp_lock_handler handler);
/**
* Remove previously registered handler. All parameters must be the same
* as when the handler was added.
*
* @param grp_lock The group lock.
* @param member A pointer to be passed to the handler.
* @param handler The destroy handler.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_del_handler(pj_grp_lock_t *grp_lock,
void *member,
pj_grp_lock_handler handler);
/**
* Increment reference counter to prevent the group lock grom being destroyed.
*
* @param grp_lock The group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
#if !PJ_GRP_LOCK_DEBUG
PJ_DECL(pj_status_t) pj_grp_lock_add_ref(pj_grp_lock_t *grp_lock);
/**
* Debug version of pj_grp_lock_add_ref(), allowing to specify file and lineno.
*
* @param grp_lock The group lock.
* @param x Filename
* @param y Line number
*
* @return PJ_SUCCESS or the appropriate error code.
*/
#define pj_grp_lock_add_ref_dbg(grp_lock, x, y) pj_grp_lock_add_ref(grp_lock)
#else
#define pj_grp_lock_add_ref(g) pj_grp_lock_add_ref_dbg(g, __FILE__, __LINE__)
PJ_DECL(pj_status_t) pj_grp_lock_add_ref_dbg(pj_grp_lock_t *grp_lock,
const char *file,
int line);
#endif
/**
* Decrement the reference counter. When the counter value reaches zero, the
* group lock will be destroyed and all destructor handlers will be called.
*
* @param grp_lock The group lock.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
#if !PJ_GRP_LOCK_DEBUG
PJ_DECL(pj_status_t) pj_grp_lock_dec_ref(pj_grp_lock_t *grp_lock);
/**
* Debug version of pj_grp_lock_dec_ref(), allowing to specify file and lineno.
*
* @param grp_lock The group lock.
* @param x Filename
* @param y Line number
*
* @return PJ_SUCCESS or the appropriate error code.
*/
#define pj_grp_lock_dec_ref_dbg(grp_lock, x, y) pj_grp_lock_dec_ref(grp_lock)
#else
#define pj_grp_lock_dec_ref(g) pj_grp_lock_dec_ref_dbg(g, __FILE__, __LINE__)
PJ_DECL(pj_status_t) pj_grp_lock_dec_ref_dbg(pj_grp_lock_t *grp_lock,
const char *file,
int line);
#endif
/**
* Get current reference count value. This normally is only used for
* debugging purpose.
*
* @param grp_lock The group lock.
*
* @return The reference count value.
*/
PJ_DECL(int) pj_grp_lock_get_ref(pj_grp_lock_t *grp_lock);
/**
* Dump group lock info for debugging purpose. If group lock debugging is
* enabled (via PJ_GRP_LOCK_DEBUG) macro, this will print the group lock
* reference counter value along with the source file and line. If
* debugging is disabled, this will only print the reference counter.
*
* @param grp_lock The group lock.
*/
PJ_DECL(void) pj_grp_lock_dump(pj_grp_lock_t *grp_lock);
/**
* Synchronize an external lock with the group lock, by adding it to the
* list of locks to be acquired by the group lock when the group lock is
* acquired.
*
* The ''pos'' argument specifies the lock order and also the relative
* position with regard to lock ordering against the group lock. Locks with
* lower ''pos'' value will be locked first, and those with negative value
* will be locked before the group lock (the group lock's ''pos'' value is
* zero).
*
* @param grp_lock The group lock.
* @param ext_lock The external lock
* @param pos The position.
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_chain_lock(pj_grp_lock_t *grp_lock,
pj_lock_t *ext_lock,
int pos);
/**
* Remove an external lock from group lock's list of synchronized locks.
*
* @param grp_lock The group lock.
* @param ext_lock The external lock
*
* @return PJ_SUCCESS or the appropriate error code.
*/
PJ_DECL(pj_status_t) pj_grp_lock_unchain_lock(pj_grp_lock_t *grp_lock,
pj_lock_t *ext_lock);
/** @} */
PJ_END_DECL
#endif /* __PJ_LOCK_H__ */

487
GSMGateway/app/src/main/cpp/pj/log.h Normal file
View File

@@ -0,0 +1,487 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_LOG_H__
#define __PJ_LOG_H__
/**
* @file log.h
* @brief Logging Utility.
*/
#include <pj/types.h>
#include <stdarg.h>
PJ_BEGIN_DECL
/**
* @defgroup PJ_MISC Miscelaneous
*/
/**
* @defgroup PJ_LOG Logging Facility
* @ingroup PJ_MISC
* @{
*
* The PJLIB logging facility is a configurable, flexible, and convenient
* way to write logging or trace information.
*
* To write to the log, one uses construct like below:
*
* <pre>
* ...
* PJ_LOG(3, ("main.c", "Starting hello..."));
* ...
* PJ_LOG(3, ("main.c", "Hello world from process %d", pj_getpid()));
* ...
* </pre>
*
* In the above example, the number @b 3 controls the verbosity level of
* the information (which means "information", by convention). The string
* "main.c" specifies the source or sender of the message.
*
*
* \section pj_log_quick_sample_sec Examples
*
* For examples, see:
* - Simple Log sample: \src{pjlib/src/pjlib-samples/log.c}
*
*/
/**
* Log decoration flag, to be specified with #pj_log_set_decor().
*/
enum pj_log_decoration
{
PJ_LOG_HAS_DAY_NAME = 1, /**< Include day name [default: no] */
PJ_LOG_HAS_YEAR = 2, /**< Include year digit [no] */
PJ_LOG_HAS_MONTH = 4, /**< Include month [no] */
PJ_LOG_HAS_DAY_OF_MON = 8, /**< Include day of month [no] */
PJ_LOG_HAS_TIME = 16, /**< Include time [yes] */
PJ_LOG_HAS_MICRO_SEC = 32, /**< Include microseconds [yes] */
PJ_LOG_HAS_SENDER = 64, /**< Include sender in the log [yes] */
PJ_LOG_HAS_NEWLINE = 128, /**< Terminate each call with newline [yes] */
PJ_LOG_HAS_CR = 256, /**< Include carriage return [no] */
PJ_LOG_HAS_SPACE = 512, /**< Include two spaces before log [yes] */
PJ_LOG_HAS_COLOR = 1024, /**< Colorize logs [yes on win32] */
PJ_LOG_HAS_LEVEL_TEXT = 2048, /**< Include level text string [no] */
PJ_LOG_HAS_THREAD_ID = 4096, /**< Include thread identification [no] */
PJ_LOG_HAS_THREAD_SWC = 8192, /**< Add mark when thread has switched [yes]*/
PJ_LOG_HAS_INDENT =16384 /**< Indentation. Say yes! [yes] */
};
/**
* Write log message.
* This is the main macro used to write text to the logging backend.
*
* @param level The logging verbosity level. Lower number indicates higher
* importance, with level zero indicates fatal error. Only
* numeral argument is permitted (e.g. not variable).
* @param arg Enclosed 'printf' like arguments, with the first
* argument is the sender, the second argument is format
* string and the following arguments are variable number of
* arguments suitable for the format string.
*
* Sample:
* \verbatim
PJ_LOG(2, (__FILE__, "current value is %d", value));
\endverbatim
* @hideinitializer
*/
#define PJ_LOG(level,arg) do { \
if (level <= pj_log_get_level()) { \
pj_log_wrapper_##level(arg); \
} \
} while (0)
/**
* Signature for function to be registered to the logging subsystem to
* write the actual log message to some output device.
*
* @param level Log level.
* @param data Log message, which will be NULL terminated.
* @param len Message length.
*/
typedef void pj_log_func(int level, const char *data, int len);
/**
* Default logging writer function used by front end logger function.
* This function will print the log message to stdout only.
* Application normally should NOT need to call this function, but
* rather use the PJ_LOG macro.
*
* @param level Log level.
* @param buffer Log message.
* @param len Message length.
*/
PJ_DECL(void) pj_log_write(int level, const char *buffer, int len);
#if PJ_LOG_MAX_LEVEL >= 1
/**
* Write to log.
*
* @param sender Source of the message.
* @param level Verbosity level.
* @param format Format.
* @param marker Marker.
*/
PJ_DECL(void) pj_log(const char *sender, int level,
const char *format, va_list marker);
/**
* Change log output function. The front-end logging functions will call
* this function to write the actual message to the desired device.
* By default, the front-end functions use pj_log_write() to write
* the messages, unless it's changed by calling this function.
*
* @param func The function that will be called to write the log
* messages to the desired device.
*/
PJ_DECL(void) pj_log_set_log_func( pj_log_func *func );
/**
* Get the current log output function that is used to write log messages.
*
* @return Current log output function.
*/
PJ_DECL(pj_log_func*) pj_log_get_log_func(void);
/**
* Set maximum log level. Application can call this function to set
* the desired level of verbosity of the logging messages. The bigger the
* value, the more verbose the logging messages will be printed. However,
* the maximum level of verbosity can not exceed compile time value of
* PJ_LOG_MAX_LEVEL.
*
* @param level The maximum level of verbosity of the logging
* messages (6=very detailed..1=error only, 0=disabled)
*/
PJ_DECL(void) pj_log_set_level(int level);
/**
* Get current maximum log verbositylevel.
*
* @return Current log maximum level.
*/
#if 1
PJ_DECL(int) pj_log_get_level(void);
#else
PJ_DECL_DATA(int) pj_log_max_level;
#define pj_log_get_level() pj_log_max_level
#endif
/**
* Set log decoration. The log decoration flag controls what are printed
* to output device alongside the actual message. For example, application
* can specify that date/time information should be displayed with each
* log message.
*
* @param decor Bitmask combination of #pj_log_decoration to control
* the layout of the log message.
*/
PJ_DECL(void) pj_log_set_decor(unsigned decor);
/**
* Get current log decoration flag.
*
* @return Log decoration flag.
*/
PJ_DECL(unsigned) pj_log_get_decor(void);
/**
* Add indentation to log message. Indentation will add PJ_LOG_INDENT_CHAR
* before the message, and is useful to show the depth of function calls.
*
* @param indent The indentation to add or substract. Positive value
* adds current indent, negative value subtracts current
* indent.
*/
PJ_DECL(void) pj_log_add_indent(int indent);
/**
* Set indentation to specific value.
*
* @param indent The indentation value.
*/
PJ_DECL(void) pj_log_set_indent(int indent);
/**
* Get current indentation value.
*
* @return Current indentation value.
*/
PJ_DECL(int) pj_log_get_indent(void);
/**
* Push indentation to the right by default value (PJ_LOG_INDENT_SIZE).
*/
PJ_DECL(void) pj_log_push_indent(void);
/**
* Pop indentation (to the left) by default value (PJ_LOG_INDENT_SIZE).
*/
PJ_DECL(void) pj_log_pop_indent(void);
/**
* Set color of log messages.
*
* @param level Log level which color will be changed.
* @param color Desired color.
*/
PJ_DECL(void) pj_log_set_color(int level, pj_color_t color);
/**
* Get color of log messages.
*
* @param level Log level which color will be returned.
* @return Log color.
*/
PJ_DECL(pj_color_t) pj_log_get_color(int level);
/**
* Internal function to be called by pj_init()
*/
pj_status_t pj_log_init(void);
#else /* #if PJ_LOG_MAX_LEVEL >= 1 */
/**
* Change log output function. The front-end logging functions will call
* this function to write the actual message to the desired device.
* By default, the front-end functions use pj_log_write() to write
* the messages, unless it's changed by calling this function.
*
* @param func The function that will be called to write the log
* messages to the desired device.
*/
# define pj_log_set_log_func(func)
/**
* Write to log.
*
* @param sender Source of the message.
* @param level Verbosity level.
* @param format Format.
* @param marker Marker.
*/
# define pj_log(sender, level, format, marker)
/**
* Set maximum log level. Application can call this function to set
* the desired level of verbosity of the logging messages. The bigger the
* value, the more verbose the logging messages will be printed. However,
* the maximum level of verbosity can not exceed compile time value of
* PJ_LOG_MAX_LEVEL.
*
* @param level The maximum level of verbosity of the logging
* messages (6=very detailed..1=error only, 0=disabled)
*/
# define pj_log_set_level(level)
/**
* Set log decoration. The log decoration flag controls what are printed
* to output device alongside the actual message. For example, application
* can specify that date/time information should be displayed with each
* log message.
*
* @param decor Bitmask combination of #pj_log_decoration to control
* the layout of the log message.
*/
# define pj_log_set_decor(decor)
/**
* Add indentation to log message. Indentation will add PJ_LOG_INDENT_CHAR
* before the message, and is useful to show the depth of function calls.
*
* @param indent The indentation to add or substract. Positive value
* adds current indent, negative value subtracts current
* indent.
*/
# define pj_log_add_indent(indent)
/**
* Set indentation to specific value.
*
* @param indent The indentation value.
*/
# define pj_log_set_indent(indent)
/**
* Get current indentation value.
*
* @return Current indentation value.
*/
# define pj_log_get_indent() 0
/**
* Push indentation to the right by default value (PJ_LOG_INDENT_SIZE).
*/
# define pj_log_push_indent()
/**
* Pop indentation (to the left) by default value (PJ_LOG_INDENT_SIZE).
*/
# define pj_log_pop_indent()
/**
* Set color of log messages.
*
* @param level Log level which color will be changed.
* @param color Desired color.
*/
# define pj_log_set_color(level, color)
/**
* Get current maximum log verbositylevel.
*
* @return Current log maximum level.
*/
# define pj_log_get_level() 0
/**
* Get current log decoration flag.
*
* @return Log decoration flag.
*/
# define pj_log_get_decor() 0
/**
* Get color of log messages.
*
* @param level Log level which color will be returned.
* @return Log color.
*/
# define pj_log_get_color(level) 0
/**
* Internal.
*/
# define pj_log_init() PJ_SUCCESS
#endif /* #if PJ_LOG_MAX_LEVEL >= 1 */
/**
* @}
*/
/* **************************************************************************/
/*
* Log functions implementation prototypes.
* These functions are called by PJ_LOG macros according to verbosity
* level specified when calling the macro. Applications should not normally
* need to call these functions directly.
*/
/**
* @def pj_log_wrapper_1(arg)
* Internal function to write log with verbosity 1. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 1.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 1
#define pj_log_wrapper_1(arg) pj_log_1 arg
/** Internal function. */
PJ_DECL(void) pj_log_1(const char *src, const char *format, ...)
PJ_PRINT_FUNC_DECOR(2);
#else
#define pj_log_wrapper_1(arg)
#endif
/**
* @def pj_log_wrapper_2(arg)
* Internal function to write log with verbosity 2. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 2.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 2
#define pj_log_wrapper_2(arg) pj_log_2 arg
/** Internal function. */
PJ_DECL(void) pj_log_2(const char *src, const char *format, ...)
PJ_PRINT_FUNC_DECOR(2);
#else
#define pj_log_wrapper_2(arg)
#endif
/**
* @def pj_log_wrapper_3(arg)
* Internal function to write log with verbosity 3. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 3.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 3
#define pj_log_wrapper_3(arg) pj_log_3 arg
/** Internal function. */
PJ_DECL(void) pj_log_3(const char *src, const char *format, ...)
PJ_PRINT_FUNC_DECOR(2);
#else
#define pj_log_wrapper_3(arg)
#endif
/**
* @def pj_log_wrapper_4(arg)
* Internal function to write log with verbosity 4. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 4.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 4
#define pj_log_wrapper_4(arg) pj_log_4 arg
/** Internal function. */
PJ_DECL(void) pj_log_4(const char *src, const char *format, ...)
PJ_PRINT_FUNC_DECOR(2);
#else
#define pj_log_wrapper_4(arg)
#endif
/**
* @def pj_log_wrapper_5(arg)
* Internal function to write log with verbosity 5. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 5.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 5
#define pj_log_wrapper_5(arg) pj_log_5 arg
/** Internal function. */
PJ_DECL(void) pj_log_5(const char *src, const char *format, ...)
PJ_PRINT_FUNC_DECOR(2);
#else
#define pj_log_wrapper_5(arg)
#endif
/**
* @def pj_log_wrapper_6(arg)
* Internal function to write log with verbosity 6. Will evaluate to
* empty expression if PJ_LOG_MAX_LEVEL is below 6.
* @param arg Log expression.
*/
#if PJ_LOG_MAX_LEVEL >= 6
#define pj_log_wrapper_6(arg) pj_log_6 arg
/** Internal function. */
PJ_DECL(void) pj_log_6(const char *src, const char *format, ...)
PJ_PRINT_FUNC_DECOR(2);
#else
#define pj_log_wrapper_6(arg)
#endif
PJ_END_DECL
#endif /* __PJ_LOG_H__ */

203
GSMGateway/app/src/main/cpp/pj/math.h Normal file
View File

@@ -0,0 +1,203 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_MATH_H__
#define __PJ_MATH_H__
/**
* @file math.h
* @brief Mathematics and Statistics.
*/
#include <pj/string.h>
#include <pj/compat/high_precision.h>
PJ_BEGIN_DECL
/**
* @defgroup pj_math Mathematics and Statistics
* @ingroup PJ_MISC
* @{
*
* Provides common mathematics constants and operations, and also standard
* statistics calculation (min, max, mean, standard deviation). Statistics
* calculation is done in realtime (statistics state is updated on time each
* new sample comes).
*/
/**
* Mathematical constants
*/
/** pi */
#define PJ_PI 3.14159265358979323846 /* pi */
/** 1/pi */
#define PJ_1_PI 0.318309886183790671538 /* 1/pi */
/**
* Mathematical macros
*/
/** Get the absolute value */
#define PJ_ABS(x) ((x) > 0 ? (x) : -(x))
/** Get the maximum of two values */
#define PJ_MAX(x, y) ((x) > (y)? (x) : (y))
/** Get the minimum of two values */
#define PJ_MIN(x, y) ((x) < (y)? (x) : (y))
/**
* This structure describes statistics state.
*/
typedef struct pj_math_stat
{
int n; /**< number of samples */
int max; /**< maximum value */
int min; /**< minimum value */
int last; /**< last value */
int mean; /**< mean */
/* Private members */
#if PJ_HAS_FLOATING_POINT
float fmean_; /**< mean(floating point) */
#else
int mean_res_; /**< mean residue */
#endif
pj_highprec_t m2_; /**< variance * n */
} pj_math_stat;
/**
* Calculate integer square root of an integer.
*
* @param i Integer to be calculated.
*
* @return Square root result.
*/
PJ_INLINE(unsigned) pj_isqrt(unsigned i)
{
unsigned res = 1, prev;
/* Rough guess, calculate half bit of input */
prev = i >> 2;
while (prev) {
prev >>= 2;
res <<= 1;
}
/* Babilonian method */
do {
prev = res;
res = (prev + i/prev) >> 1;
} while ((prev+res)>>1 != res);
return res;
}
/**
* Initialize statistics state.
*
* @param stat Statistic state.
*/
PJ_INLINE(void) pj_math_stat_init(pj_math_stat *stat)
{
pj_bzero(stat, sizeof(pj_math_stat));
}
/**
* Update statistics state as a new sample comes.
*
* @param stat Statistic state.
* @param val The new sample data.
*/
PJ_INLINE(void) pj_math_stat_update(pj_math_stat *stat, int val)
{
#if PJ_HAS_FLOATING_POINT
float delta;
#else
int delta;
#endif
stat->last = val;
if (stat->n++) {
if (stat->min > val)
stat->min = val;
if (stat->max < val)
stat->max = val;
} else {
stat->min = stat->max = val;
}
#if PJ_HAS_FLOATING_POINT
delta = val - stat->fmean_;
stat->fmean_ += delta/stat->n;
/* Return mean value with 'rounding' */
stat->mean = (int) (stat->fmean_ + 0.5);
stat->m2_ += (int)(delta * (val-stat->fmean_));
#else
delta = val - stat->mean;
stat->mean += delta/stat->n;
stat->mean_res_ += delta % stat->n;
if (stat->mean_res_ >= stat->n) {
++stat->mean;
stat->mean_res_ -= stat->n;
} else if (stat->mean_res_ <= -stat->n) {
--stat->mean;
stat->mean_res_ += stat->n;
}
stat->m2_ += delta * (val-stat->mean);
#endif
}
/**
* Get the standard deviation of specified statistics state.
*
* @param stat Statistic state.
*
* @return The standard deviation.
*/
PJ_INLINE(unsigned) pj_math_stat_get_stddev(const pj_math_stat *stat)
{
if (stat->n == 0) return 0;
return (pj_isqrt((unsigned)(stat->m2_/stat->n)));
}
/**
* Set the standard deviation of statistics state. This is useful when
* the statistic state is operated in 'read-only' mode as a storage of
* statistical data.
*
* @param stat Statistic state.
*
* @param dev The standard deviation.
*/
PJ_INLINE(void) pj_math_stat_set_stddev(pj_math_stat *stat, unsigned dev)
{
if (stat->n == 0)
stat->n = 1;
stat->m2_ = dev*dev*stat->n;
}
/** @} */
PJ_END_DECL
#endif /* __PJ_MATH_H__ */

1536
GSMGateway/app/src/main/cpp/pj/os.h Normal file
View File

File diff suppressed because it is too large Load Diff

918
GSMGateway/app/src/main/cpp/pj/pool.h Normal file
View File

@@ -0,0 +1,918 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <pj/list.h>
/* See if we use pool's alternate API.
* The alternate API is used e.g. to implement pool debugging.
*/
#if PJ_HAS_POOL_ALT_API
# include <pj/pool_alt.h>
#endif
#ifndef __PJ_POOL_H__
#define __PJ_POOL_H__
/**
* @file pool.h
* @brief Memory Pool.
*/
PJ_BEGIN_DECL
/**
* @defgroup PJ_POOL_GROUP Fast Memory Pool
* @brief
* Memory pools allow dynamic memory allocation comparable to malloc or the
* new in operator C++. Those implementations are not desirable for very
* high performance applications or real-time systems, because of the
* performance bottlenecks and it suffers from fragmentation issue.
*
* \section PJ_POOL_INTRO_SEC PJLIB's Memory Pool
* \subsection PJ_POOL_ADVANTAGE_SUBSEC Advantages
*
* PJLIB's pool has many advantages over traditional malloc/new operator and
* over other memory pool implementations, because:
* - unlike other memory pool implementation, it allows allocation of
* memory chunks of different sizes,
* - it's very very fast.
* \n
* Memory chunk allocation is not only an O(1)
* operation, but it's also very simple (just
* few pointer arithmetic operations) and it doesn't require locking
* any mutex,
* - it's memory efficient.
* \n
* Pool doesn't keep track individual memory chunks allocated by
* applications, so there is no additional overhead needed for each
* memory allocation (other than possible additional of few bytes, up to
* PJ_POOL_ALIGNMENT-1, for aligning the memory).
* But see the @ref PJ_POOL_CAVEATS_SUBSEC below.
* - it prevents memory leaks.
* \n
* Memory pool inherently has garbage collection functionality. In fact,
* there is no need to free the chunks allocated from the memory pool.
* All chunks previously allocated from the pool will be freed once the
* pool itself is destroyed. This would prevent memory leaks that haunt
* programmers for decades, and it provides additional performance
* advantage over traditional malloc/new operator.
*
* Even more, PJLIB's memory pool provides some additional usability and
* flexibility for applications:
* - memory leaks are easily traceable, since memory pool is assigned name,
* and application can inspect what pools currently active in the system.
* - by design, memory allocation from a pool is not thread safe. We assumed
* that a pool will be owned by a higher level object, and thread safety
* should be handled by that object. This enables very fast pool operations
* and prevents unnecessary locking operations,
* - by default, the memory pool API behaves more like C++ new operator,
* in that it will throw PJ_NO_MEMORY_EXCEPTION exception (see
* @ref PJ_EXCEPT) when memory chunk allocation fails. This enables failure
* handling to be done on more high level function (instead of checking
* the result of pj_pool_alloc() everytime). If application doesn't like
* this, the default behavior can be changed on global basis by supplying
* different policy to the pool factory.
* - any memory allocation backend allocator/deallocator may be used. By
* default, the policy uses malloc() and free() to manage the pool's block,
* but application may use different strategy, for example to allocate
* memory blocks from a globally static memory location.
*
*
* \subsection PJ_POOL_PERFORMANCE_SUBSEC Performance
*
* The result of PJLIB's memory design and careful implementation is a
* memory allocation strategy that can speed-up the memory allocations
* and deallocations by up to <b>30 times</b> compared to standard
* malloc()/free() (more than 150 million allocations per second on a
* P4/3.0GHz Linux machine).
*
* (Note: your mileage may vary, of course. You can see how much PJLIB's
* pool improves the performance over malloc()/free() in your target
* system by running pjlib-test application).
*
*
* \subsection PJ_POOL_CAVEATS_SUBSEC Caveats
*
* There are some caveats though!
*
* When creating pool, PJLIB requires applications to specify the initial
* pool size, and as soon as the pool is created, PJLIB allocates memory
* from the system by that size. Application designers MUST choose the
* initial pool size carefully, since choosing too big value will result in
* wasting system's memory.
*
* But the pool can grow. Application designer can specify how the
* pool will grow in size, by specifying the size increment when creating
* the pool.
*
* The pool, however, <b>cannot</b> shrink! Since there is <b>no</b>
* function to deallocate memory chunks, there is no way for the pool to
* release back unused memory to the system.
* Application designers must be aware that constant memory allocations
* from pool that has infinite life-time may cause the memory usage of
* the application to grow over time.
*
*
* \section PJ_POOL_USING_SEC Using Memory Pool
*
* This section describes how to use PJLIB's memory pool framework.
* As we hope the readers will witness, PJLIB's memory pool API is quite
* straightforward.
*
* \subsection PJ_POOL_USING_F Create Pool Factory
* First, application needs to initialize a pool factory (this normally
* only needs to be done once in one application). PJLIB provides
* a pool factory implementation called caching pool (see @ref
* PJ_CACHING_POOL), and it is initialized by calling #pj_caching_pool_init().
*
* \subsection PJ_POOL_USING_P Create The Pool
* Then application creates the pool object itself with #pj_pool_create(),
* specifying among other thing the pool factory where the pool should
* be created from, the pool name, initial size, and increment/expansion
* size.
*
* \subsection PJ_POOL_USING_M Allocate Memory as Required
* Then whenever application needs to allocate dynamic memory, it would
* call #pj_pool_alloc(), #pj_pool_calloc(), or #pj_pool_zalloc() to
* allocate memory chunks from the pool.
*
* \subsection PJ_POOL_USING_DP Destroy the Pool
* When application has finished with the pool, it should call
* #pj_pool_release() to release the pool object back to the factory.
* Depending on the types of the factory, this may release the memory back
* to the operating system.
*
* \subsection PJ_POOL_USING_Dc Destroy the Pool Factory
* And finally, before application quites, it should deinitialize the
* pool factory, to make sure that all memory blocks allocated by the
* factory are released back to the operating system. After this, of
* course no more memory pool allocation can be requested.
*
* \subsection PJ_POOL_USING_EX Example
* Below is a sample complete program that utilizes PJLIB's memory pool.
*
* \code
#include <pjlib.h>
#define THIS_FILE "pool_sample.c"
static void my_perror(const char *title, pj_status_t status)
{
PJ_PERROR(1,(THIS_FILE, status, title));
}
static void pool_demo_1(pj_pool_factory *pfactory)
{
unsigned i;
pj_pool_t *pool;
// Must create pool before we can allocate anything
pool = pj_pool_create(pfactory, // the factory
"pool1", // pool's name
4000, // initial size
4000, // increment size
NULL); // use default callback.
if (pool == NULL) {
my_perror("Error creating pool", PJ_ENOMEM);
return;
}
// Demo: allocate some memory chunks
for (i=0; i<1000; ++i) {
void *p;
p = pj_pool_alloc(pool, (pj_rand()+1) % 512);
// Do something with p
...
// Look! No need to free p!!
}
// Done with silly demo, must free pool to release all memory.
pj_pool_release(pool);
}
int main()
{
pj_caching_pool cp;
pj_status_t status;
// Must init PJLIB before anything else
status = pj_init();
if (status != PJ_SUCCESS) {
my_perror("Error initializing PJLIB", status);
return 1;
}
// Create the pool factory, in this case, a caching pool,
// using default pool policy.
pj_caching_pool_init(&cp, NULL, 1024*1024 );
// Do a demo
pool_demo_1(&cp.factory);
// Done with demos, destroy caching pool before exiting app.
pj_caching_pool_destroy(&cp);
return 0;
}
\endcode
*
* More information about pool factory, the pool object, and caching pool
* can be found on the Module Links below.
*/
/**
* @defgroup PJ_POOL Memory Pool Object
* @ingroup PJ_POOL_GROUP
* @brief
* The memory pool is an opaque object created by pool factory.
* Application uses this object to request a memory chunk, by calling
* #pj_pool_alloc(), #pj_pool_calloc(), or #pj_pool_zalloc().
* When the application has finished using
* the pool, it must call #pj_pool_release() to free all the chunks previously
* allocated and release the pool back to the factory.
*
* A memory pool is initialized with an initial amount of memory, which is
* called a block. Pool can be configured to dynamically allocate more memory
* blocks when it runs out of memory.
*
* The pool doesn't keep track of individual memory allocations
* by user, and the user doesn't have to free these indidual allocations. This
* makes memory allocation simple and very fast. All the memory allocated from
* the pool will be destroyed when the pool itself is destroyed.
*
* \section PJ_POOL_THREADING_SEC More on Threading Policies
* - By design, memory allocation from a pool is not thread safe. We assumed
* that a pool will be owned by an object, and thread safety should be
* handled by that object. Thus these functions are not thread safe:
* - #pj_pool_alloc,
* - #pj_pool_calloc,
* - and other pool statistic functions.
* - Threading in the pool factory is decided by the policy set for the
* factory when it was created.
*
* \section PJ_POOL_EXAMPLES_SEC Examples
*
* For some sample codes on how to use the pool, please see:
* - Pool test: \src{pjlib/src/pjlib-test/pool.c}
*
* @{
*/
/**
* The type for function to receive callback from the pool when it is unable
* to allocate memory. The elegant way to handle this condition is to throw
* exception, and this is what is expected by most of this library
* components.
*/
typedef void pj_pool_callback(pj_pool_t *pool, pj_size_t size);
/**
* This class, which is used internally by the pool, describes a single
* block of memory from which user memory allocations will be allocated from.
*/
typedef struct pj_pool_block
{
PJ_DECL_LIST_MEMBER(struct pj_pool_block); /**< List's prev and next. */
unsigned char *buf; /**< Start of buffer. */
unsigned char *cur; /**< Current alloc ptr. */
unsigned char *end; /**< End of buffer. */
} pj_pool_block;
/**
* This structure describes the memory pool. Only implementors of pool factory
* need to care about the contents of this structure.
*/
struct pj_pool_t
{
PJ_DECL_LIST_MEMBER(struct pj_pool_t); /**< Standard list elements. */
/** Pool name */
char obj_name[PJ_MAX_OBJ_NAME];
/** Pool factory. */
pj_pool_factory *factory;
/** Data put by factory */
void *factory_data;
/** Current capacity allocated by the pool. */
pj_size_t capacity;
/** Size of memory block to be allocated when the pool runs out of memory */
pj_size_t increment_size;
/** List of memory blocks allcoated by the pool. */
pj_pool_block block_list;
/** The callback to be called when the pool is unable to allocate memory. */
pj_pool_callback *callback;
};
/**
* Guidance on how much memory required for initial pool administrative data.
*/
#define PJ_POOL_SIZE (sizeof(struct pj_pool_t))
/**
* Pool memory alignment (must be power of 2).
*/
#ifndef PJ_POOL_ALIGNMENT
# define PJ_POOL_ALIGNMENT 4
#endif
/**
* Create a new pool from the pool factory. This wrapper will call create_pool
* member of the pool factory.
*
* @param factory The pool factory.
* @param name The name to be assigned to the pool. The name should
* not be longer than PJ_MAX_OBJ_NAME (32 chars), or
* otherwise it will be truncated.
* @param initial_size The size of initial memory blocks taken by the pool.
* Note that the pool will take 68+20 bytes for
* administrative area from this block.
* @param increment_size the size of each additional blocks to be allocated
* when the pool is running out of memory. If user
* requests memory which is larger than this size, then
* an error occurs.
* Note that each time a pool allocates additional block,
* it needs PJ_POOL_SIZE more to store some
* administrative info.
* @param callback Callback to be called when error occurs in the pool.
* If this value is NULL, then the callback from pool
* factory policy will be used.
* Note that when an error occurs during pool creation,
* the callback itself is not called. Instead, NULL
* will be returned.
*
* @return The memory pool, or NULL.
*/
PJ_IDECL(pj_pool_t*) pj_pool_create(pj_pool_factory *factory,
const char *name,
pj_size_t initial_size,
pj_size_t increment_size,
pj_pool_callback *callback);
/**
* Release the pool back to pool factory.
*
* @param pool Memory pool.
*/
PJ_IDECL(void) pj_pool_release( pj_pool_t *pool );
/**
* Release the pool back to pool factory and set the pool pointer to zero.
*
* @param ppool Pointer to memory pool.
*/
PJ_IDECL(void) pj_pool_safe_release( pj_pool_t **ppool );
/**
* Release the pool back to pool factory and set the pool pointer to zero.
* The memory pool content will be wiped out first before released.
*
* @param ppool Pointer to memory pool.
*/
PJ_IDECL(void) pj_pool_secure_release( pj_pool_t **ppool );
/**
* Get pool object name.
*
* @param pool the pool.
*
* @return pool name as NULL terminated string.
*/
PJ_IDECL(const char *) pj_pool_getobjname( const pj_pool_t *pool );
/**
* Reset the pool to its state when it was initialized.
* This means that if additional blocks have been allocated during runtime,
* then they will be freed. Only the original block allocated during
* initialization is retained. This function will also reset the internal
* counters, such as pool capacity and used size.
*
* @param pool the pool.
*/
PJ_DECL(void) pj_pool_reset( pj_pool_t *pool );
/**
* Get the pool capacity, that is, the system storage that have been allocated
* by the pool, and have been used/will be used to allocate user requests.
* There's no guarantee that the returned value represent a single
* contiguous block, because the capacity may be spread in several blocks.
*
* @param pool the pool.
*
* @return the capacity.
*/
PJ_IDECL(pj_size_t) pj_pool_get_capacity( pj_pool_t *pool );
/**
* Get the total size of user allocation request.
*
* @param pool the pool.
*
* @return the total size.
*/
PJ_IDECL(pj_size_t) pj_pool_get_used_size( pj_pool_t *pool );
/**
* Allocate storage with the specified size from the pool.
* If there's no storage available in the pool, then the pool can allocate more
* blocks if the increment size is larger than the requested size.
*
* @param pool the pool.
* @param size the requested size.
*
* @return pointer to the allocated memory.
*
* @see PJ_POOL_ALLOC_T
*/
PJ_IDECL(void*) pj_pool_alloc( pj_pool_t *pool, pj_size_t size);
/**
* Allocate storage from the pool, and initialize it to zero.
* This function behaves like pj_pool_alloc(), except that the storage will
* be initialized to zero.
*
* @param pool the pool.
* @param count the number of elements in the array.
* @param elem the size of individual element.
*
* @return pointer to the allocated memory.
*/
PJ_IDECL(void*) pj_pool_calloc( pj_pool_t *pool, pj_size_t count,
pj_size_t elem);
/**
* Allocate storage from the pool and initialize it to zero.
*
* @param pool The pool.
* @param size The size to be allocated.
*
* @return Pointer to the allocated memory.
*
* @see PJ_POOL_ZALLOC_T
*/
PJ_INLINE(void*) pj_pool_zalloc(pj_pool_t *pool, pj_size_t size)
{
return pj_pool_calloc(pool, 1, size);
}
/**
* This macro allocates memory from the pool and returns the instance of
* the specified type. It provides a stricker type safety than pj_pool_alloc()
* since the return value of this macro will be type-casted to the specified
* type.
*
* @param pool The pool
* @param type The type of object to be allocated
*
* @return Memory buffer of the specified type.
*/
#define PJ_POOL_ALLOC_T(pool,type) \
((type*)pj_pool_alloc(pool, sizeof(type)))
/**
* This macro allocates memory from the pool, zeroes the buffer, and
* returns the instance of the specified type. It provides a stricker type
* safety than pj_pool_zalloc() since the return value of this macro will be
* type-casted to the specified type.
*
* @param pool The pool
* @param type The type of object to be allocated
*
* @return Memory buffer of the specified type.
*/
#define PJ_POOL_ZALLOC_T(pool,type) \
((type*)pj_pool_zalloc(pool, sizeof(type)))
/*
* Internal functions
*/
/** Internal function */
PJ_IDECL(void*) pj_pool_alloc_from_block(pj_pool_block *block, pj_size_t size);
/** Internal function */
PJ_DECL(void*) pj_pool_allocate_find(pj_pool_t *pool, pj_size_t size);
/**
* @} // PJ_POOL
*/
/* **************************************************************************/
/**
* @defgroup PJ_POOL_FACTORY Pool Factory and Policy
* @ingroup PJ_POOL_GROUP
* @brief
* A pool object must be created through a factory. A factory not only provides
* generic interface functions to create and release pool, but also provides
* strategy to manage the life time of pools. One sample implementation,
* \a pj_caching_pool, can be set to keep the pools released by application for
* future use as long as the total memory is below the limit.
*
* The pool factory interface declared in PJLIB is designed to be extensible.
* Application can define its own strategy by creating it's own pool factory
* implementation, and this strategy can be used even by existing library
* without recompilation.
*
* \section PJ_POOL_FACTORY_ITF Pool Factory Interface
* The pool factory defines the following interface:
* - \a policy: the memory pool factory policy.
* - \a create_pool(): create a new memory pool.
* - \a release_pool(): release memory pool back to factory.
*
* \section PJ_POOL_FACTORY_POL Pool Factory Policy.
*
* A pool factory only defines functions to create and release pool and how
* to manage pools, but the rest of the functionalities are controlled by
* policy. A pool policy defines:
* - how memory block is allocated and deallocated (the default implementation
* allocates and deallocate memory by calling malloc() and free()).
* - callback to be called when memory allocation inside a pool fails (the
* default implementation will throw PJ_NO_MEMORY_EXCEPTION exception).
* - concurrency when creating and releasing pool from/to the factory.
*
* A pool factory can be given different policy during creation to make
* it behave differently. For example, caching pool factory can be configured
* to allocate and deallocate from a static/contiguous/preallocated memory
* instead of using malloc()/free().
*
* What strategy/factory and what policy to use is not defined by PJLIB, but
* instead is left to application to make use whichever is most efficient for
* itself.
*
* The pool factory policy controls the behaviour of memory factories, and
* defines the following interface:
* - \a block_alloc(): allocate memory block from backend memory mgmt/system.
* - \a block_free(): free memory block back to backend memory mgmt/system.
* @{
*/
/* We unfortunately don't have support for factory policy options as now,
so we keep this commented at the moment.
enum PJ_POOL_FACTORY_OPTION
{
PJ_POOL_FACTORY_SERIALIZE = 1
};
*/
/**
* This structure declares pool factory interface.
*/
typedef struct pj_pool_factory_policy
{
/**
* Allocate memory block (for use by pool). This function is called
* by memory pool to allocate memory block.
*
* @param factory Pool factory.
* @param size The size of memory block to allocate.
*
* @return Memory block.
*/
void* (*block_alloc)(pj_pool_factory *factory, pj_size_t size);
/**
* Free memory block.
*
* @param factory Pool factory.
* @param mem Memory block previously allocated by block_alloc().
* @param size The size of memory block.
*/
void (*block_free)(pj_pool_factory *factory, void *mem, pj_size_t size);
/**
* Default callback to be called when memory allocation fails.
*/
pj_pool_callback *callback;
/**
* Option flags.
*/
unsigned flags;
} pj_pool_factory_policy;
/**
* This constant denotes the exception number that will be thrown by default
* memory factory policy when memory allocation fails.
*
* @see pj_NO_MEMORY_EXCEPTION()
*/
PJ_DECL_DATA(int) PJ_NO_MEMORY_EXCEPTION;
/**
* Get #PJ_NO_MEMORY_EXCEPTION constant.
*/
PJ_DECL(int) pj_NO_MEMORY_EXCEPTION(void);
/**
* This global variable points to default memory pool factory policy.
* The behaviour of the default policy is:
* - block allocation and deallocation use malloc() and free().
* - callback will raise PJ_NO_MEMORY_EXCEPTION exception.
* - access to pool factory is not serialized (i.e. not thread safe).
*
* @see pj_pool_factory_get_default_policy
*/
PJ_DECL_DATA(pj_pool_factory_policy) pj_pool_factory_default_policy;
/**
* Get the default pool factory policy.
*
* @return the pool policy.
*/
PJ_DECL(const pj_pool_factory_policy*) pj_pool_factory_get_default_policy(void);
/**
* This structure contains the declaration for pool factory interface.
*/
struct pj_pool_factory
{
/**
* Memory pool policy.
*/
pj_pool_factory_policy policy;
/**
* Create a new pool from the pool factory.
*
* @param factory The pool factory.
* @param name the name to be assigned to the pool. The name should
* not be longer than PJ_MAX_OBJ_NAME (32 chars), or
* otherwise it will be truncated.
* @param initial_size the size of initial memory blocks taken by the pool.
* Note that the pool will take 68+20 bytes for
* administrative area from this block.
* @param increment_size the size of each additional blocks to be allocated
* when the pool is running out of memory. If user
* requests memory which is larger than this size, then
* an error occurs.
* Note that each time a pool allocates additional block,
* it needs 20 bytes (equal to sizeof(pj_pool_block)) to
* store some administrative info.
* @param callback Cllback to be called when error occurs in the pool.
* Note that when an error occurs during pool creation,
* the callback itself is not called. Instead, NULL
* will be returned.
*
* @return the memory pool, or NULL.
*/
pj_pool_t* (*create_pool)( pj_pool_factory *factory,
const char *name,
pj_size_t initial_size,
pj_size_t increment_size,
pj_pool_callback *callback);
/**
* Release the pool to the pool factory.
*
* @param factory The pool factory.
* @param pool The pool to be released.
*/
void (*release_pool)( pj_pool_factory *factory, pj_pool_t *pool );
/**
* Dump pool status to log.
*
* @param factory The pool factory.
*/
void (*dump_status)( pj_pool_factory *factory, pj_bool_t detail );
/**
* This is optional callback to be called by allocation policy when
* it allocates a new memory block. The factory may use this callback
* for example to keep track of the total number of memory blocks
* currently allocated by applications.
*
* @param factory The pool factory.
* @param size Size requested by application.
*
* @return MUST return PJ_TRUE, otherwise the block
* allocation is cancelled.
*/
pj_bool_t (*on_block_alloc)(pj_pool_factory *factory, pj_size_t size);
/**
* This is optional callback to be called by allocation policy when
* it frees memory block. The factory may use this callback
* for example to keep track of the total number of memory blocks
* currently allocated by applications.
*
* @param factory The pool factory.
* @param size Size freed.
*/
void (*on_block_free)(pj_pool_factory *factory, pj_size_t size);
};
/**
* This function is intended to be used by pool factory implementors.
* @param factory Pool factory.
* @param name Pool name.
* @param initial_size Initial size.
* @param increment_size Increment size.
* @param callback Callback.
* @return The pool object, or NULL.
*/
PJ_DECL(pj_pool_t*) pj_pool_create_int( pj_pool_factory *factory,
const char *name,
pj_size_t initial_size,
pj_size_t increment_size,
pj_pool_callback *callback);
/**
* This function is intended to be used by pool factory implementors.
* @param pool The pool.
* @param name Pool name.
* @param increment_size Increment size.
* @param callback Callback function.
*/
PJ_DECL(void) pj_pool_init_int( pj_pool_t *pool,
const char *name,
pj_size_t increment_size,
pj_pool_callback *callback);
/**
* This function is intended to be used by pool factory implementors.
* @param pool The memory pool.
*/
PJ_DECL(void) pj_pool_destroy_int( pj_pool_t *pool );
/**
* Dump pool factory state.
* @param pf The pool factory.
* @param detail Detail state required.
*/
PJ_INLINE(void) pj_pool_factory_dump( pj_pool_factory *pf,
pj_bool_t detail )
{
(*pf->dump_status)(pf, detail);
}
/**
* @} // PJ_POOL_FACTORY
*/
/* **************************************************************************/
/**
* @defgroup PJ_CACHING_POOL Caching Pool Factory
* @ingroup PJ_POOL_GROUP
* @brief
* Caching pool is one sample implementation of pool factory where the
* factory can reuse memory to create a pool. Application defines what the
* maximum memory the factory can hold, and when a pool is released the
* factory decides whether to destroy the pool or to keep it for future use.
* If the total amount of memory in the internal cache is still within the
* limit, the factory will keep the pool in the internal cache, otherwise the
* pool will be destroyed, thus releasing the memory back to the system.
*
* @{
*/
/**
* Number of unique sizes, to be used as index to the free list.
* Each pool in the free list is organized by it's size.
*/
#define PJ_CACHING_POOL_ARRAY_SIZE 16
/**
* Declaration for caching pool. Application doesn't normally need to
* care about the contents of this struct, it is only provided here because
* application need to define an instance of this struct (we can not allocate
* the struct from a pool since there is no pool factory yet!).
*/
struct pj_caching_pool
{
/** Pool factory interface, must be declared first. */
pj_pool_factory factory;
/** Current factory's capacity, i.e. number of bytes that are allocated
* and available for application in this factory. The factory's
* capacity represents the size of all pools kept by this factory
* in it's free list, which will be returned to application when it
* requests to create a new pool.
*/
pj_size_t capacity;
/** Maximum size that can be held by this factory. Once the capacity
* has exceeded @a max_capacity, further #pj_pool_release() will
* flush the pool. If the capacity is still below the @a max_capacity,
* #pj_pool_release() will save the pool to the factory's free list.
*/
pj_size_t max_capacity;
/**
* Number of pools currently held by applications. This number gets
* incremented everytime #pj_pool_create() is called, and gets
* decremented when #pj_pool_release() is called.
*/
pj_size_t used_count;
/**
* Total size of memory currently used by application.
*/
pj_size_t used_size;
/**
* The maximum size of memory used by application throughout the life
* of the caching pool.
*/
pj_size_t peak_used_size;
/**
* Lists of pools in the cache, indexed by pool size.
*/
pj_list free_list[PJ_CACHING_POOL_ARRAY_SIZE];
/**
* List of pools currently allocated by applications.
*/
pj_list used_list;
/**
* Internal pool.
*/
char pool_buf[256 * (sizeof(size_t) / 4)];
/**
* Mutex.
*/
pj_lock_t *lock;
};
/**
* Initialize caching pool.
*
* @param ch_pool The caching pool factory to be initialized.
* @param policy Pool factory policy.
* @param max_capacity The total capacity to be retained in the cache. When
* the pool is returned to the cache, it will be kept in
* recycling list if the total capacity of pools in this
* list plus the capacity of the pool is still below this
* value.
*/
PJ_DECL(void) pj_caching_pool_init( pj_caching_pool *ch_pool,
const pj_pool_factory_policy *policy,
pj_size_t max_capacity);
/**
* Destroy caching pool, and release all the pools in the recycling list.
*
* @param ch_pool The caching pool.
*/
PJ_DECL(void) pj_caching_pool_destroy( pj_caching_pool *ch_pool );
/**
* @} // PJ_CACHING_POOL
*/
# if PJ_FUNCTIONS_ARE_INLINED
# include "pool_i.h"
# endif
PJ_END_DECL
#endif /* __PJ_POOL_H__ */

212
GSMGateway/app/src/main/cpp/pj/pool_alt.h Normal file
View File

@@ -0,0 +1,212 @@
/*
* Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
* Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __PJ_POOL_ALT_H__
#define __PJ_POOL_ALT_H__
#define __PJ_POOL_H__
PJ_BEGIN_DECL
/**
* The type for function to receive callback from the pool when it is unable
* to allocate memory. The elegant way to handle this condition is to throw
* exception, and this is what is expected by most of this library
* components.
*/
typedef void pj_pool_callback(pj_pool_t *pool, pj_size_t size);
struct pj_pool_mem
{
struct pj_pool_mem *next;
/* data follows immediately */
};
struct pj_pool_t
{
struct pj_pool_mem *first_mem;
pj_pool_factory *factory;
char obj_name[32];
pj_size_t used_size;
pj_pool_callback *cb;
};
#define PJ_POOL_SIZE (sizeof(struct pj_pool_t))
/**
* This constant denotes the exception number that will be thrown by default
* memory factory policy when memory allocation fails.
*/
PJ_DECL_DATA(int) PJ_NO_MEMORY_EXCEPTION;
/**
* Get #PJ_NO_MEMORY_EXCEPTION constant.
*/
PJ_DECL(int) pj_NO_MEMORY_EXCEPTION(void);
/*
* Declare all pool API as macro that calls the implementation
* function.
*/
#define pj_pool_create(fc,nm,init,inc,cb) \
pj_pool_create_imp(__FILE__, __LINE__, fc, nm, init, inc, cb)
#define pj_pool_release(pool) pj_pool_release_imp(pool)
#define pj_pool_safe_release(pool) pj_pool_safe_release_imp(pool)
#define pj_pool_secure_release(pool) pj_pool_secure_release_imp(pool)
#define pj_pool_getobjname(pool) pj_pool_getobjname_imp(pool)
#define pj_pool_reset(pool) pj_pool_reset_imp(pool)
#define pj_pool_get_capacity(pool) pj_pool_get_capacity_imp(pool)
#define pj_pool_get_used_size(pool) pj_pool_get_used_size_imp(pool)
#define pj_pool_alloc(pool,sz) \
pj_pool_alloc_imp(__FILE__, __LINE__, pool, sz)
#define pj_pool_calloc(pool,cnt,elem) \
pj_pool_calloc_imp(__FILE__, __LINE__, pool, cnt, elem)
#define pj_pool_zalloc(pool,sz) \
pj_pool_zalloc_imp(__FILE__, __LINE__, pool, sz)
/*
* Declare prototypes for pool implementation API.
*/
/* Create pool */
PJ_DECL(pj_pool_t*) pj_pool_create_imp(const char *file, int line,
void *factory,
const char *name,
pj_size_t initial_size,
pj_size_t increment_size,
pj_pool_callback *callback);
/* Release pool */
PJ_DECL(void) pj_pool_release_imp(pj_pool_t *pool);
/* Safe release pool */
PJ_DECL(void) pj_pool_safe_release_imp(pj_pool_t **pool);
/* Secure release pool */
PJ_DECL(void) pj_pool_secure_release_imp(pj_pool_t **pool);
/* Get pool name */
PJ_DECL(const char*) pj_pool_getobjname_imp(pj_pool_t *pool);
/* Reset pool */
PJ_DECL(void) pj_pool_reset_imp(pj_pool_t *pool);
/* Get capacity */
PJ_DECL(pj_size_t) pj_pool_get_capacity_imp(pj_pool_t *pool);
/* Get total used size */
PJ_DECL(pj_size_t) pj_pool_get_used_size_imp(pj_pool_t *pool);
/* Allocate memory from the pool */
PJ_DECL(void*) pj_pool_alloc_imp(const char *file, int line,
pj_pool_t *pool, pj_size_t sz);
/* Allocate memory from the pool and zero the memory */
PJ_DECL(void*) pj_pool_calloc_imp(const char *file, int line,
pj_pool_t *pool, unsigned cnt,
unsigned elemsz);
/* Allocate memory from the pool and zero the memory */
PJ_DECL(void*) pj_pool_zalloc_imp(const char *file, int line,
pj_pool_t *pool, pj_size_t sz);
#define PJ_POOL_ZALLOC_T(pool,type) \
((type*)pj_pool_zalloc(pool, sizeof(type)))
#define PJ_POOL_ALLOC_T(pool,type) \
((type*)pj_pool_alloc(pool, sizeof(type)))
#ifndef PJ_POOL_ALIGNMENT
# define PJ_POOL_ALIGNMENT 4
#endif
/**
* This structure declares pool factory interface.
*/
typedef struct pj_pool_factory_policy
{
/**
* Allocate memory block (for use by pool). This function is called
* by memory pool to allocate memory block.
*
* @param factory Pool factory.
* @param size The size of memory block to allocate.
*
* @return Memory block.
*/
void* (*block_alloc)(pj_pool_factory *factory, pj_size_t size);
/**
* Free memory block.
*
* @param factory Pool factory.
* @param mem Memory block previously allocated by block_alloc().
* @param size The size of memory block.
*/
void (*block_free)(pj_pool_factory *factory, void *mem, pj_size_t size);
/**
* Default callback to be called when memory allocation fails.
*/
pj_pool_callback *callback;
/**
* Option flags.
*/
unsigned flags;
} pj_pool_factory_policy;
struct pj_pool_factory
{
pj_pool_factory_policy policy;
int dummy;
};
struct pj_caching_pool
{
pj_pool_factory factory;
/* just to make it compilable */
unsigned used_count;
unsigned used_size;
unsigned peak_used_size;
};
/* just to make it compilable */
typedef struct pj_pool_block
{
int dummy;
} pj_pool_block;
#define pj_caching_pool_init( cp, pol, mac)
#define pj_caching_pool_destroy(cp)
#define pj_pool_factory_dump(pf, detail)
PJ_END_DECL
#endif /* __PJ_POOL_ALT_H__ */

Some files were not shown because too many files have changed in this diff Show More