bool
rtspcl_announce_sdp(struct rtspcl_data *rtspcld, const char *sdp,
GError **error_r)
{
return exec_request(rtspcld, "ANNOUNCE", "application/sdp", sdp, 1,
NULL, NULL, error_r);
}
bool
rtspcl_set_parameter(struct rtspcl_data *rtspcld, const char *parameter,
GError **error_r)
{
return exec_request(rtspcld, "SET_PARAMETER", "text/parameters",
parameter, 1, NULL, NULL, error_r);
}
void ImpTradeSession::login(void) {
std::string program = "410301";
KCBPCLIHANDLE handle = connect_gateway();
int_request(handle, program);
// set function request parameter
KCBPCLI_SetValue(handle, "inputtype", "Z");//登录类型 inputtype char(1) Y 见备注
KCBPCLI_SetValue(handle, "inputid", (char *) _account.c_str());//登录标识 inputid char(64) Y 见备注
// execute request
record_set result;
exec_request(handle, program, result);
disconnect_gateway(handle);
// process answer
result.show_data();
_cust_id = result.get_field_value("custid");
try {
_creditflag = result.get_field_value("creditflag");
}
catch(std::exception &e){
_creditflag = "0";
}
char enpassword[255];
memset(enpassword, 0, 255);
encode_dll_wrapper::instance()->Encrypt(_accountPassword.c_str(), enpassword, _cust_id.c_str(), _encryptType);
_encode_password.assign(enpassword);
//获得股东账户
_secuid.clear();
for(size_t row = 0; row< result.get_row_size(); row++){
std::string k = result.get_field_value("market",row+1);
std::string v = result.get_field_value("secuid",row+1);
if( k.size()>0 && v.size()>0 ){
_secuid[k] = v;
}
}
}
bool
rtspcl_record(struct rtspcl_data *rtspcld,
int seq_num, int rtptime,
GError **error_r)
{
if (!rtspcld->session) {
g_set_error_literal(error_r, rtsp_client_quark(), 0,
"no session in progress");
return false;
}
char buf[128];
sprintf(buf, "seq=%d,rtptime=%u", seq_num, rtptime);
struct key_data rtp;
static char rtp_key[] = "RTP-Info";
rtp.key = rtp_key;
rtp.data = buf;
rtp.next = NULL;
struct key_data range;
static char range_key[] = "Range";
range.key = range_key;
static char range_value[] = "npt=0-";
range.data = range_value;
range.next = &rtp;
return exec_request(rtspcld, "RECORD", NULL, NULL, 1, &range,
NULL, error_r);
}
int rtspcl_teardown(rtspcl_t *p)
{
rtspcl_data_t *rtspcld;
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
return exec_request(rtspcld, "TEARDOWN", NULL, NULL, 0, 1, NULL, &rtspcld->kd, NULL);
}
int rtspcl_options(rtspcl_t *p)
{
rtspcl_data_t *rtspcld;
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
return exec_request(rtspcld, "OPTIONS", NULL, NULL, 0, 1, NULL, &rtspcld->kd, "*");
}
int rtspcl_set_parameter(rtspcl_t *p, char *para)
{
rtspcl_data_t *rtspcld;
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
return exec_request(rtspcld, "SET_PARAMETER", "text/parameters", para, 0, 1, NULL, &rtspcld->kd, NULL);
}
int rtspcl_announce_sdp(rtspcl_t *p, char *sdp)
{
rtspcl_data_t *rtspcld;
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
return exec_request(rtspcld, "ANNOUNCE", "application/sdp", sdp, 0, 1, NULL, &rtspcld->kd, NULL);
}
static int subsystem_request(ssh_session session, ssh_channel channel,
const char *subsystem, void *userdata) {
/* subsystem requests behave simillarly to exec requests. */
if (strcmp(subsystem, "sftp") == 0) {
return exec_request(session, channel, SFTP_SERVER_PATH, userdata);
}
return SSH_ERROR;
}
error_t session_display(bool use_tcp, bool use_udp, bool use_icmp)
{
unsigned char request[HDR_LEN + PAYLOAD_LEN];
struct request_hdr *hdr = (struct request_hdr *) request;
struct request_session *payload = (struct request_session *) (request + HDR_LEN);
hdr->length = sizeof(request);
hdr->mode = MODE_SESSION;
hdr->operation = OP_DISPLAY;
return exec_request(use_tcp, use_udp, use_icmp, hdr, payload, session_display_response);
}
int rtspcl_flush(rtspcl_t *p)
{
key_data_t hds[2];
rtspcl_data_t *rtspcld;
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
hds[0].key=(uint8_t*)"RTP-Info";
hds[0].data=(uint8_t*)"seq=0;rtptime=0";
hds[1].key=NULL;
return exec_request(rtspcld, "FLUSH", NULL, NULL, 0, 1, hds, &rtspcld->kd, NULL);
}
error_t session_remove_ipv6(bool use_tcp, bool use_udp, bool use_icmp, struct ipv6_pair *pair6)
{
unsigned char request[HDR_LEN + PAYLOAD_LEN];
struct request_hdr *hdr = (struct request_hdr *) request;
struct request_session *payload = (struct request_session *) (request + HDR_LEN);
hdr->length = sizeof(request);
hdr->mode = MODE_SESSION;
hdr->operation = OP_REMOVE;
payload->remove.l3_proto = 6;
payload->remove.pair6 = *pair6;
return exec_request(use_tcp, use_udp, use_icmp, hdr, payload, session_remove_response);
}
void ImpTradeSession::call_410502(void) {
std::string program = "410502";
KCBPCLIHANDLE handle = connect_gateway();
int_request(handle, program);
// set function request parameter
KCBPCLI_SetValue(handle, "fundid", "");
KCBPCLI_SetValue(handle, "moneytype", "");
// execute request
record_set result;
exec_request(handle, program, result);
disconnect_gateway(handle);
// process answer
result.show_data();
}
error_t session_add(bool use_tcp, bool use_udp, bool use_icmp, struct ipv6_pair *pair6,
struct ipv4_pair *pair4)
{
unsigned char request[HDR_LEN + PAYLOAD_LEN];
struct request_hdr *hdr = (struct request_hdr *) request;
struct request_session *payload = (struct request_session *) (request + HDR_LEN);
hdr->length = sizeof(request);
hdr->mode = MODE_SESSION;
hdr->operation = OP_ADD;
payload->add.pair6 = *pair6;
payload->add.pair4 = *pair4;
return exec_request(use_tcp, use_udp, use_icmp, hdr, payload, session_add_response);
}
_public_
int knot_requestor_exec(struct knot_requestor *requestor,
struct timeval *timeout)
{
if (knot_requestor_finished(requestor)) {
return KNOT_ENOENT;
}
/* Execute next request. */
int ret = exec_request(requestor, HEAD(requestor->pending), timeout);
/* Remove it from processing. */
knot_requestor_dequeue(requestor);
return ret;
}
int rtspcl_set_daap(rtspcl_t *p, char *para, unsigned long timestamp, int count)
{
key_data_t hds[2];
char rtptime[20];
rtspcl_data_t *rtspcld;
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
sprintf(rtptime, "rtptime=%ld",timestamp);
hds[0].key=(uint8_t*)"RTP-Info";
hds[0].data=(uint8_t*)rtptime;
hds[1].key=NULL;
return exec_request(rtspcld, "SET_PARAMETER", "application/x-dmap-tagged", para, count, 2, hds, &rtspcld->kd, NULL);
}
//服务器端执行入口函数
int main(int argc, char*argv[]){
struct sigaction new_action, old_action;
message_data message_request;
new_action.sa_handler=catch_signals;
sigemptyset(&new_action.sa_mask);
new_action.sa_flags=0;
if ((sigaction(SIGINT, &new_action, &old_action) != 0) ||
(sigaction(SIGHUP, &new_action, &old_action) != 0) ||
(sigaction(SIGTERM, &new_action, &old_action) != 0)) {
fprintf(stderr, "Server startup error, signal catching failed\n");
exit(EXIT_FAILURE);
}
char* server_host="localhost";
char* sql_username="******";
char* sql_password="******";
char* db_name="railwaysystem";
if(!database_init(server_host, sql_username, sql_password, db_name)){
fprintf(stderr, "Server error: could not init database. \n");
sys_log("数据库连接失败.");
exit(EXIT_FAILURE);
}
sys_log("数据库连接成功.");
if(!server_start()){
sys_log("服务器启动失败.");
exit(EXIT_FAILURE);
}
sys_log("服务器启动成功.");
while(server_state){
if(read_request_from_client(&message_request)){
exec_request(message_request);
}else{
if(server_state){
fprintf(stderr, "Server ended, cannot read request from message queue. \n");
sys_log("Server ended, cannot read request from message queue.");
}
server_state=0;
}
}
database_close();
server_end();
sys_log("服务器关闭.");
exit(EXIT_SUCCESS);
}
int rtspcl_auth_setup(rtspcl_t *p)
{
rtspcl_data_t *rtspcld;
/* //itunes second
char data[] = {
0x01, 0x80, 0xc3, 0xb3, 0xe8, 0xd6, 0x22, 0xd0, 0x50, 0xeb, 0xd8,
0x17, 0x40, 0x11, 0xd8, 0x93, 0x00, 0x55, 0x65, 0xe7, 0x56, 0x43,
0x76, 0xff, 0x41, 0x12, 0x84, 0x92, 0xac, 0xfb, 0xec, 0xd4, 0x1d }; */
//itunes first
char data[] = {
0x01, 0xad, 0xb2, 0xa4, 0xc7, 0xd5, 0x5c, 0x97, 0x6c, 0x34, 0xf9,
0x2e, 0x0e, 0x05, 0x48, 0x90, 0x3b, 0x3a, 0x2f, 0xc6, 0x72, 0x2b,
0x88, 0x58, 0x08, 0x76, 0xd2, 0x9c, 0x61, 0x94, 0x18, 0x52, 0x50 };
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
return exec_request(rtspcld, "POST", "application/octet-stream", data, 33, 1, NULL, &rtspcld->kd,"/auth-setup");
}
int rtspcl_record(rtspcl_t *p)
{
key_data_t hds[3];
rtspcl_data_t *rtspcld;
struct timeval now;
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
if(!rtspcld->session){
ERRMSG("%s: no session in progress\n",__func__);
return -1;
}
gettimeofday(&now,NULL);
hds[0].key=(uint8_t*)"Range";
hds[0].data=(uint8_t*)"npt=0-";
hds[1].key=(uint8_t*)"RTP-Info";
hds[1].data=(uint8_t*)"seq=0;rtptime=0";
hds[2].key=NULL;
return exec_request(rtspcld,"RECORD",NULL,NULL,0,1,hds,&rtspcld->kd, NULL);
}
// Called when all of the processing on the outer requests has finished.
static int outer_done(struct request *r)
{
DEBUG("[%d] Request received, processing it.\n", r->fd);
// The request has finished sending all of its data. Process it.
r->data[r->outer_index] = NULL;
r->buffer = &r->buffer_char;
r->buffer_len = 0;
r->inner_index = 0;
r->inner_len = 0;
r->string_len = 0;
// Check to see that the user sent a command.
if (r->data == NULL || r->outer_len < 1 || r->data[0][0] == NULL) {
ERROR("[%d] Command is missing from request.\n", r->fd);
initd_response_protocol_error(r);
} else if (!strncmp(r->data[0][0], "CHROOT", 7)) {
chroot_request(r);
} else if (!strncmp(r->data[0][0], "SETHOSTNAME", 12)) {
sethostname_request(r);
} else if (!strncmp(r->data[0][0], "EXEC", 5)) {
exec_request(r);
} else if (!strncmp(r->data[0][0], "START", 6)) {
start_request(r);
} else if (!strncmp(r->data[0][0], "MOUNT", 6)) {
mount_request(r);
} else if (!strncmp(r->data[0][0], "STATUS", 7)) {
status_request(r);
} else if (!strncmp(r->data[0][0], "WAIT", 5)) {
wait_request(r);
} else {
// This is an unknown request!
ERROR("[%d] Unknown command: %s\n", r->fd, r->data[0][0]);
initd_response_protocol_error(r);
}
// Let the reader know that this request is done processing.
return 1;
}
TradeAPI::InstrumentDetailsDict ImpTradeSession::qryInstruments(const std::string &mkt, const std::string &secType) {
std::string program = "410203";
KCBPCLIHANDLE handle = connect_gateway();
int_request(handle, program);
// set function request parameter
if( mkt == "SSE"){
KCBPCLI_SetValue(handle, "market", _SHA.c_str());
}
else if( mkt == "SZSE"){
KCBPCLI_SetValue(handle, "market", _SZA.c_str());
}
KCBPCLI_SetValue(handle, "stkcode", "");
// execute request
record_set result;
exec_request(handle, program, result);
disconnect_gateway(handle);
// process answer
result.show_data();
return TradeAPI::InstrumentDetailsDict();
}
bool
rtspcl_setup(struct rtspcl_data *rtspcld, struct key_data **kd,
int control_port, int ntp_port,
GError **error_r)
{
struct key_data *rkd = NULL, hds;
const char delimiters[] = ";";
char *buf = NULL;
char *token, *pc;
int rval = false;
static char transport_key[] = "Transport";
char transport_value[256];
snprintf(transport_value, sizeof(transport_value),
"RTP/AVP/UDP;unicast;interleaved=0-1;mode=record;control_port=%d;timing_port=%d",
control_port, ntp_port);
hds.key = transport_key;
hds.data = transport_value;
hds.next = NULL;
if (!exec_request(rtspcld, "SETUP", NULL, NULL, 1,
&hds, &rkd, error_r))
return false;
if (!(rtspcld->session = g_strdup(kd_lookup(rkd, "Session")))) {
g_set_error_literal(error_r, rtsp_client_quark(), 0,
"no session in response");
goto erexit;
}
if (!(rtspcld->transport = kd_lookup(rkd, "Transport"))) {
g_set_error_literal(error_r, rtsp_client_quark(), 0,
"no transport in response");
goto erexit;
}
buf = g_strdup(rtspcld->transport);
token = strtok(buf, delimiters);
rtspcld->server_port = 0;
rtspcld->control_port = 0;
while (token) {
if ((pc = strstr(token, "="))) {
*pc = 0;
if (!strcmp(token,"server_port")) {
rtspcld->server_port=atoi(pc + 1);
}
if (!strcmp(token,"control_port")) {
rtspcld->control_port=atoi(pc + 1);
}
}
token = strtok(NULL, delimiters);
}
if (rtspcld->server_port == 0) {
g_set_error_literal(error_r, rtsp_client_quark(), 0,
"no server_port in response");
goto erexit;
}
if (rtspcld->control_port == 0) {
g_set_error_literal(error_r, rtsp_client_quark(), 0,
"no control_port in response");
goto erexit;
}
rval = true;
erexit:
g_free(buf);
if (!rval || kd == NULL) {
free_kd(rkd);
rkd = NULL;
}
if (kd != NULL)
*kd = rkd;
return rval;
}
void ImpTradeSession::exec_order(TradeAPI::OrderPtr &ord) {
//发送委托到三方接口
std::string program;
KCBPCLIHANDLE handle;
try {
handle = connect_gateway();
if (_creditflag == "1") { //信用账户
program = "420411";
int_request(handle, program);
// set function request parameter
KCBPCLI_SetValue(handle, "fundid", ord->account.c_str());
if (ord->inst.exchange == "SSE") {
KCBPCLI_SetValue(handle, "market", _SHA.c_str());
KCBPCLI_SetValue(handle, "secuid", _secuid[_SHA].c_str());
}
else if (ord->inst.exchange == "SZSE") {
KCBPCLI_SetValue(handle, "market", _SZA.c_str());
KCBPCLI_SetValue(handle, "secuid", _secuid[_SZA].c_str());
}
KCBPCLI_SetValue(handle, "stkcode", ord->inst.symbol.c_str());
KCBPCLI_SetValue(handle, "price", DoubleToString(ord->lmtPrice, 10).c_str());
KCBPCLI_SetValue(handle, "qty", IntToString((int) ord->ordQty).c_str());
std::string bsflag;
if (ord->side == "LendBuy" || ord->side == "SellRepayment" || ord->side == "Repayment") {
KCBPCLI_SetValue(handle, "credittype", "1"); //融资交易
}
else if (ord->side == "BorrowSell" || ord->side == "BuyGiveBack" || ord->side == "GiveBack") {
KCBPCLI_SetValue(handle, "credittype", "2"); //融券交易
}
else {
KCBPCLI_SetValue(handle, "credittype", "0"); //普通交易
}
if (ord->side == "Buy" || ord->side == "LendBuy" || ord->side == "BuyGiveBack") {
if (ord->type == "Limit") {
bsflag = "B";
}
else if (ord->type == "Market0") {
bsflag = "a";
}
else if (ord->type == "Market1") {
bsflag = "b";
}
else if (ord->type == "Market3") {
bsflag = "c";
}
else if (ord->type == "Market5") {
bsflag = "d";
}
else if (ord->type == "Market") {
bsflag = "e";
}
else {
bsflag = "B";
}
}
else if (ord->side == "Sell" || ord->side == "SellRepayment") {
if (ord->type == "Limit") {
bsflag = "S";
}
else if (ord->type == "Market0") {
bsflag = "f";
}
else if (ord->type == "Market1") {
bsflag = "g";
}
else if (ord->type == "Market3") {
bsflag = "h";
}
else if (ord->type == "Market5") {
bsflag = "i";
}
else if (ord->type == "Market") {
bsflag = "j";
}
else {
bsflag = "S";
}
}
else if (ord->side == "BorrowSell") {
if (ord->type == "Limit") {
bsflag = "S";
}
}
KCBPCLI_SetValue(handle, "bsflag", bsflag.c_str());
}
else { //普通账户
program = "410411";
int_request(handle, program);
// set function request parameter
KCBPCLI_SetValue(handle, "fundid", ord->account.c_str());
std::string bsflag;
if (ord->side == "Buy") {
if (ord->type == "Limit") {
bsflag = "B";
}
else if (ord->type == "Market0") {
bsflag = "a";
}
else if (ord->type == "Market1") {
bsflag = "b";
}
else if (ord->type == "Market3") {
bsflag = "c";
}
else if (ord->type == "Market5") {
bsflag = "d";
}
else if (ord->type == "Market") {
bsflag = "e";
}
else {
bsflag = "B";
}
}
else if (ord->side == "Sell") {
if (ord->type == "Limit") {
bsflag = "S";
}
else if (ord->type == "Market0") {
bsflag = "f";
}
else if (ord->type == "Market1") {
bsflag = "g";
}
else if (ord->type == "Market3") {
bsflag = "h";
}
else if (ord->type == "Market5") {
bsflag = "i";
}
else if (ord->type == "Market") {
bsflag = "j";
}
else {
bsflag = "S";
}
}
else if (ord->side == "Subscribe") {
if (ord->type == "Limit") {
bsflag = "1";
}
}
else if (ord->side == "Redeem") {
if (ord->type == "Limit") {
bsflag = "2";
}
}
KCBPCLI_SetValue(handle, "bsflag", bsflag.c_str());
if (ord->inst.exchange == "SSE") {
KCBPCLI_SetValue(handle, "market", _SHA.c_str());
KCBPCLI_SetValue(handle, "secuid", _secuid[_SHA].c_str());
}
else if (ord->inst.exchange == "SZSE") {
KCBPCLI_SetValue(handle, "market", _SZA.c_str());
KCBPCLI_SetValue(handle, "secuid", _secuid[_SZA].c_str());
}
KCBPCLI_SetValue(handle, "stkcode", ord->inst.symbol.c_str());
KCBPCLI_SetValue(handle, "price", DoubleToString(ord->lmtPrice, 10).c_str());
KCBPCLI_SetValue(handle, "qty", IntToString((int) ord->ordQty).c_str());
KCBPCLI_SetValue(handle, "ordergroup", "-1");
}
}
catch(std::exception &e){
ord->text = std::string("Order rejected before send it:") + e.what();
ord->report.ordStatus = OrderStatus::OSRejected;
return;
}
// execute request
record_set result;
try {
exec_request(handle, program, result);
}
catch(std::exception &e){
ord->text = std::string("Order rejected in sending:") + e.what();
ord->report.ordStatus = OrderStatus::OSRejected;
return;
}
disconnect_gateway(handle);
// process answer
result.show_data();
//获得委托号
try {
ord->ordId = result.get_field_value("ordersno");
}
catch(std::exception &e){
ord->text = std::string("Order rejected after send it:") + e.what();
ord->report.ordStatus = OrderStatus::OSRejected;
return;
}
//更新状态
ord->report.ordStatus = OrderStatus::OSPendingNew;
std::pair<OrderDict::iterator,bool> ret;
std::unique_lock<std::mutex> lck(_mtx_all_orders);
ret = _working_orders.insert(std::pair<std::string, OrderPtr>(ord->ordId,ord));
if (!ret.second) {
//委托号已经存在，可能出现重复位委托号，覆盖旧的委托
ord->text = "Replaced an old order with the same ordId.";
_working_orders[ord->ordId] = ord;
}
}
int rtspcl_setup(rtspcl_t *p, key_data_t **kd)
{
key_data_t *rkd=NULL;
key_data_t hds[2];
const char delimiters[] = ";";
char *buf=NULL;
char *token,*pc;
char *temp;
int rval=-1;
rtspcl_data_t *rtspcld;
if(!p) return -1;
rtspcld=(rtspcl_data_t *)p;
hds[0].key=(uint8_t*)"Transport";
hds[0].data=(uint8_t*)"RTP/AVP/UDP;unicast;interleaved=0-1;mode=record;control_port=6001;timing_port=6002";
hds[1].key=NULL;
if(exec_request(rtspcld, "SETUP", NULL, NULL, 0, 1, hds, &rkd, NULL)) return -1;
if(!(temp=kd_lookup(rkd, "Session"))){
ERRMSG("%s: no session in response\n",__func__);
goto erexit;
}
DBGMSG("<------- : %s: session:%s\n",__func__,temp);
rtspcld->session = (char *) malloc(100);
sprintf( rtspcld->session, "%s", trim(temp) );
if(!(rtspcld->transport=kd_lookup(rkd, "Transport"))){
ERRMSG("%s: no transport in responce\n",__func__);
goto erexit;
}
if(realloc_memory((void*)&buf,strlen(rtspcld->transport)+1,__func__)) goto erexit;
strcpy(buf,rtspcld->transport);
token=strtok(buf,delimiters);
rtspcld->server_port=0;
while(token)
{
if((pc=strstr(token,"=")))
{
*pc=0;
if(!strcmp(token,"server_port"))
{
rtspcld->server_port=atoi(pc+1);
DBGMSG( "got server port : %d\n", rtspcld->server_port );
}
if(!strcmp(token,"control_port"))
{
rtspcld->control_port=atoi(pc+1);
DBGMSG( "got control port : %d\n", rtspcld->control_port );
}
if(!strcmp(token,"timing_port"))
{
rtspcld->timing_port=atoi(pc+1);
DBGMSG( "got timing port : %d\n", rtspcld->timing_port );
}
}
token=strtok(NULL,delimiters);
}
if(rtspcld->server_port==0){
ERRMSG("%s: no server_port in response\n",__func__);
goto erexit;
}
rval=0;
erexit:
if(buf) free(buf);
if(rval) {
free_kd(rkd);
rkd=NULL;
}
*kd=rkd;
return rval;
}
