25441446766

Committed 06 May 2026 02:26PM UTC coverage: 56.7% (-0.1%) from 56.83%

Build # 25441446766

Build Type

push

github

Committed by

web-flow

Commit Message

Vs security fix (#2106)

* VS Security fixes

* reformatting and update to trick sims

* cleanup

* more cleanup

* docs

* Test fix

* added stuff

* More stuff

* test fix

* trick sims update

* trick sims update2

* Rename to allowlist

* Remove returns for allow, disable, allow_all functions

* Change various function returns to bool

* Added free for getaddrinfo.

* Revise Variable Server documentation for security updates

Updated documentation to clarify that the variable server is disabled by default for security reasons and must be enabled prior to initialization. Enhanced security warnings regarding the potential risks of enabling the variable server.

* Warning update and moving adding localhost to after connections are allowed

* Clarify variable server disabled by default for security

Update documentation to clarify variable server security changes.

* Update default allowed IPs in Variable-Server.md

Clarified the default allowed IPs for the variable server.

* Add session deletion in VariableServerSessionThread_test

Fixed memory management by deleting session in the destructor.

---------

Co-authored-by: Brendan Fattig <brendan.fattig@nasa.gov>
Co-authored-by: Hong Chen <hchen99@users.noreply.github.com>
Co-authored-by: Sean Harmeyer <117398532+sharmeye@users.noreply.github.com>
Co-authored-by: Sean Harmeyer <sean.g.harmeyer@nasa.gov>

Coverage Stats

51 of 102 new or added lines in 4 files covered. (50.0%)

24 existing lines in 6 files now uncovered.

12902 of 22755 relevant lines covered (56.7%)

301334.0 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

34.06

/trick_source/sim_services/VariableServer/var_server_ext.cpp


#include <iostream>
#include <string.h>

#include "trick/VariableServer.hh"
#include "trick/exec_proto.h"
#include "trick/message_proto.h"
#include "trick/message_type.h"
#include "trick/memorymanager_c_intf.h"
#include "trick/map_trick_units_to_udunits.hh"

extern Trick::VariableServer * the_vs ;

Trick::VariableServerSessionThread * get_vst() {
    return the_vs->get_vst(pthread_self()) ;
}

Trick::VariableServerSession * get_session() {
    return the_vs->get_session(pthread_self()) ;
}

int var_add(std::string in_name) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_add(in_name) ;
    }
    return(0) ;
}

int var_add(std::string in_name, std::string in_units) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_add(in_name, in_units) ;
    }
    return(0) ;
}

int var_remove(std::string in_name) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_remove(in_name) ;
    }
    return(0) ;
}

int var_units(std::string var_name , std::string units_name) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_units(var_name , units_name) ;
    }
    return(0) ;
}

int var_exists(std::string in_name) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_exists(in_name) ;
    }
    return(0) ;
}

int var_get_stl_size(std::string in_name)
{
    Trick::VariableServerSession *session = get_session();

    if (session != NULL)
    {
        session->var_get_stl_size(in_name);
    }
    return (0);
}

int var_send_once(std::string in_name) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_send_once(in_name, 1) ;
    }
    return(0) ;
}

int var_send_once(std::string in_name, int num) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_send_once(in_name, num) ;
    }
    return(0) ;
}

int var_send() {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_send() ;
    }
    return(0) ;
}

int var_clear() {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_clear() ;
    }

    // std::cout << "Done with var_clear" << std::endl;
    return(0) ;
}

int var_cycle(double in_rate) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_cycle(in_rate) ;
    }
    return(0) ;
}

int var_pause() {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->set_pause(true) ;
    }
    return(0) ;

}

int var_unpause() {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->set_pause(false) ;
    }
    return(0) ;

}

int var_exit() {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_exit() ;
    }
    return(0) ;
}

int var_validate_address(int on_off) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_validate_address((bool)on_off) ;
    }
    return(0) ;
}

int var_debug(int level) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_debug(level) ;
    }
    return(0) ;
}

int var_ascii() {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_ascii() ;
    }
    return(0) ;
}

int var_binary() {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_binary() ;
    }
    return(0) ;
}

int var_retry_bad_ref() {
    message_publish(MSG_WARNING,"var_retry_bad_ref has been deprecated\n") ;
    return(0) ;
}

int var_binary_nonames() {
    Trick::VariableServerSession * session  = get_session();

    if (session != NULL ) {
        session->var_binary_nonames() ;
    }
    return(0) ;
}

int var_set_copy_mode(int mode) {
    Trick::VariableServerSession * session = get_session();

    if (session != NULL ) {
        session->var_set_copy_mode(mode) ;
        if ( mode == VS_COPY_SCHEDULED ) {
            the_vs->get_next_sync_call_time() ;
            the_vs->get_next_freeze_call_time() ;
        }
    }
    return 0 ;
}

int var_set_write_mode(int mode) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->var_set_write_mode(mode) ;
    }
    return 0 ;
}

int var_set_send_stdio(int mode) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->set_send_stdio((bool)mode) ;
    }
    return 0 ;
}

int var_sync(int mode) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->var_sync(mode) ;
        if ( mode ) {
            the_vs->get_next_sync_call_time() ;
            the_vs->get_next_freeze_call_time() ;
        }
    }
    return(0) ;
}

int var_set_frame_multiple(unsigned int mult) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->var_set_frame_multiple(mult) ;
    }
    return 0 ;
}

int var_set_frame_offset(unsigned int offset) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->var_set_frame_offset(offset) ;
    }
    return 0 ;
}

int var_set_freeze_frame_multiple(unsigned int mult) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->var_set_freeze_frame_multiple(mult) ;
    }
    return 0 ;
}

int var_set_freeze_frame_offset(unsigned int offset) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->var_set_freeze_frame_offset(offset) ;
    }
    return 0 ;
}

int var_byteswap(bool on_off) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->var_byteswap(on_off) ;
    }
    return(0) ;
}

int var_write_stdio(int stream , std::string text ) {
    // std::cout << "Executing var_write_stdio" << std::endl;
    Trick::VariableServerSession * session = get_session();
    if (session != NULL and session->get_send_stdio() == true) {
        session->write_stdio(stream, text) ;
    } else {
        if ( stream == 1 ) {
            fprintf( stdout , "%s" , text.c_str() ) ;
        } else {
            fprintf( stderr , "%s" , text.c_str() ) ;
        }
    }
    return(0) ;
}

int var_set_client_tag( std::string text ) {
    Trick::VariableServerSessionThread * vst = get_vst();
    if (vst != NULL) {

        vst->set_client_tag(text);

#if __linux__
#ifdef __GNUC__
#if __GNUC__ >= 4 && __GNUC_MINOR__ >= 2
        std::string short_str = std::string("VS_") + text.substr(0,12) ;
        pthread_setname_np(pthread_self(), short_str.c_str()) ;
#endif
#endif
#endif
    }
    return(0) ;
}

int var_send_list_size() {

    Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->send_list_size() ;
    }
    return(0) ;
}

int send_sie_resource() {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->send_sie_resource() ;
    }
    return 0 ;
}

int send_sie_class() {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->send_sie_class() ;
    }
    return 0 ;
}

int send_sie_enum() {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        session->send_sie_enum() ;
    }
    return 0 ;
}

int send_sie_top_level_objects() {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        return session->send_sie_top_level_objects() ;
    }
    return 0 ;
}

int send_file(std::string file_name) {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        return session->send_file(file_name) ;
    }
    return 0 ;
}


// Command to turn on log to playback file
int var_server_log_on() {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        return session->set_log(true) ;
    }
    return 0 ;
}

// Command to turn off log to playback file
int var_server_log_off() {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        return session->set_log(false) ;
    }
    return 0 ;
}

// Command to turn on log to playback file
int var_server_session_log_on() {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        return session->set_session_log(true) ;
    }
    return 0 ;
}

// Command to turn off log to playback file
int var_server_session_log_off() {
Trick::VariableServerSession * session = get_session();
    if (session != NULL ) {
        return session->set_session_log(false) ;
    }
    return 0 ;
}

Trick::VariableServer * var_server_get_var_server() {
    return the_vs ;
}

extern "C" void var_server_list_connections(void) {
    std::cout << *the_vs << std::endl;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::get_hostname
 * C wrapper Trick::VariableServer::get_hostname
 */
extern "C" const char * var_server_get_hostname(void) {
    const char * ret = (the_vs->get_hostname()) ;
    return ret;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::get_port
 * C wrapper Trick::VariableServer::get_port
 */
extern "C" unsigned short var_server_get_port(void) {
    return(the_vs->get_listen_thread().get_port()) ;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::set_port
 * C wrapper Trick::VariableServer::set_port
 */
extern "C" void var_server_set_port(unsigned short port) {
    the_vs->get_listen_thread().set_port(port);
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::set_listen_socket
 * C wrapper Trick::VariableServer::set_listen_socket
 */
extern "C" void var_server_set_source_address(const char * source_address) {
    the_vs->get_listen_thread().set_source_address(source_address) ;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::get_user_tag
 * C wrapper Trick::VariableServer::get_user_tag
 */
extern "C" const char * var_server_get_user_tag(void) {
    return(the_vs->get_listen_thread().get_user_tag_ref().c_str()) ;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::set_user_tag
 * C wrapper Trick::VariableServer::set_user_tag
 */
extern "C" void var_server_set_user_tag(const char * in_tag) {
    the_vs->get_listen_thread().set_user_tag(std::string(in_tag));
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::get_enabled
 * C wrapper Trick::VariableServer::get_enabled
 */
extern "C" int var_server_get_enabled(void) {
    return(the_vs->get_enabled()) ;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::set_enabled
 * C wrapper Trick::VariableServer::set_enabled
 */
extern "C" void var_server_set_enabled(int on_off) {
    the_vs->set_enabled((bool)on_off) ;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::create_udp_socket
 * C wrapper Trick::VariableServer::create_udp_socket
 */
extern "C" int var_server_create_tcp_socket(const char * source_address, unsigned short port) {
    the_vs->create_tcp_socket(source_address, port) ;
    return 0 ;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::create_udp_socket
 * C wrapper Trick::VariableServer::create_udp_socket
 */
extern "C" int var_server_create_udp_socket(const char * source_address, unsigned short port) {
    the_vs->create_udp_socket(source_address, port) ;
    return 0 ;
}

/**
 * @relates Trick::VariableServer
 * @copydoc Trick::VariableServer::create_multicast_socket
 * C wrapper Trick::VariableServer::create_multicast_socket
 */
extern "C" int var_server_create_multicast_socket(const char * mcast_address,
 const char * source_address, unsigned short port) {
    return the_vs->create_multicast_socket(mcast_address, source_address, port) ;
}

template<class T>
void var_set_value( V_DATA & v_data , T value ) ;

template<>
void var_set_value< double > ( V_DATA & v_data , double value ) {
    v_data.value.d = value ;
    v_data.type = TRICK_DOUBLE ;
}

template<>
void var_set_value< long long > ( V_DATA & v_data , long long value ) {
    v_data.value.ll = value ;
    v_data.type = TRICK_LONG_LONG ;
}

template<>
void var_set_value< const char * > ( V_DATA & v_data , const char * value ) {
    v_data.value.cp = (char *)value ;
    v_data.type = TRICK_STRING ;
}

template<>
void var_set_value< void * > ( V_DATA & v_data , void * value ) {
    v_data.value.vp = value ;
    v_data.type = TRICK_VOID_PTR ;
}

template<class T>
int var_set_base( const char  * var , T value , const char * units ) {
    REF2 *ref = ref_attributes(var) ;
    if ( ref != NULL ) {
        if (ref->attr->io & TRICK_VAR_INPUT) {
            V_TREE v_tree ;
            V_DATA v_data ;
            v_tree.v_data = &v_data ;
            var_set_value( v_data , value) ;
            if ( units != NULL ) {
                ref->units = strdup(map_trick_units_to_udunits(units).c_str()) ;
            } else {
                ref->units = NULL ;
            }
            ref_assignment(ref , &v_tree) ;

            // Free allocated memory within a REF2 structure. Does not free the REF2 itself
            ref_free(ref) ;

            // Free the REF2 structure itself
            free(ref) ;
            ref = NULL;
        } else {
            message_publish(MSG_WARNING,"Cannot assign to %s because io_spec does not allow input\n", var) ;
            return 1;
        }
    } else {
        message_publish(MSG_WARNING,"reference attributes not found for variable %s in call to var_set\n", var) ;
        return 2;
    }
    return 0 ;
}

int var_set( const char  * var , double value , const char * units ) {
    return var_set_base(var, value, units) ;
}

int var_set( const char  * var , long long value , const char * units ) {
    return var_set_base(var, value, units) ;
}

int var_set( const char  * var , const char * value , const char * units ) {
    return var_set_base(var, value, units) ;
}

int var_set( const char  * var , void * value , const char * units ) {
    return var_set_base(var, value, units) ;
}

void var_allow_connections() {
    var_server_set_enabled(true) ;
    the_vs->set_allow_connections(true) ;
}

void var_disable_connections() {
    var_server_set_enabled(false) ;
    the_vs->set_allow_connections(false) ;
}

void var_allow_all_connections() {
    var_allow_connections() ;
    the_vs->set_bypass_ip_check(true) ;
}

void var_resolve_hostname() {
    the_vs->resolve_hostname() ;
}

bool var_set_allow_connections(bool b) {
    return the_vs->set_allow_connections(b) ;
}

bool var_get_allow_connections() {
    return the_vs->get_allow_connections() ;
}

int var_set_ip_check_bypass(bool b) {
    return the_vs->set_bypass_ip_check(b) ;
}

int var_get_ip_check_bypass() {
    return the_vs->get_bypass_ip_check() ;
}

void var_add_ip(const std::string& ip) {
    the_vs->add_ip(ip) ;
}

void var_remove_ip(const std::string& ip) {
    the_vs->remove_ip(ip) ;
}

1
2	#include <iostream>
3	#include <string.h>
4
5	#include "trick/VariableServer.hh"
6	#include "trick/exec_proto.h"
7	#include "trick/message_proto.h"
8	#include "trick/message_type.h"
9	#include "trick/memorymanager_c_intf.h"
10	#include "trick/map_trick_units_to_udunits.hh"
11
12	extern Trick::VariableServer * the_vs ;
13
14	Trick::VariableServerSessionThread * get_vst() {	5✔
15	return the_vs->get_vst(pthread_self()) ;	5✔
16	}
17
18	Trick::VariableServerSession * get_session() {	1,069✔
19	return the_vs->get_session(pthread_self()) ;	1,069✔
20	}
21
22	int var_add(std::string in_name) {	23✔
23	Trick::VariableServerSession * session = get_session();	23✔
24
25	if (session != NULL ) {	23✔
26	session->var_add(in_name) ;	23✔
27	}
28	return(0) ;	23✔
29	}
30
31	int var_add(std::string in_name, std::string in_units) {	×
32	Trick::VariableServerSession * session = get_session();	×
33
34	if (session != NULL ) {	×
35	session->var_add(in_name, in_units) ;	×
36	}
37	return(0) ;	×
38	}
39
40	int var_remove(std::string in_name) {	×
41	Trick::VariableServerSession * session = get_session();	×
42
43	if (session != NULL ) {	×
44	session->var_remove(in_name) ;	×
45	}
46	return(0) ;	×
47	}
48
49	int var_units(std::string var_name , std::string units_name) {	×
50	Trick::VariableServerSession * session = get_session();	×
51
52	if (session != NULL ) {	×
53	session->var_units(var_name , units_name) ;	×
54	}
55	return(0) ;	×
56	}
57
58	int var_exists(std::string in_name) {	×
59	Trick::VariableServerSession * session = get_session();	×
60
61	if (session != NULL ) {	×
62	session->var_exists(in_name) ;	×
63	}
64	return(0) ;	×
65	}
66
67	int var_get_stl_size(std::string in_name)	×
68	{
69	Trick::VariableServerSession *session = get_session();	×
70
71	if (session != NULL)	×
72	{
73	session->var_get_stl_size(in_name);	×
74	}
75	return (0);	×
76	}
77
78	int var_send_once(std::string in_name) {	3✔
79	Trick::VariableServerSession * session = get_session();	3✔
80
81	if (session != NULL ) {	3✔
82	session->var_send_once(in_name, 1) ;	3✔
83	}
84	return(0) ;	3✔
85	}
86
87	int var_send_once(std::string in_name, int num) {	×
88	Trick::VariableServerSession * session = get_session();	×
89
90	if (session != NULL ) {	×
91	session->var_send_once(in_name, num) ;	×
92	}
93	return(0) ;	×
94	}
95
96	int var_send() {	1✔
97	Trick::VariableServerSession * session = get_session();	1✔
98
99	if (session != NULL ) {	1✔
100	session->var_send() ;	1✔
101	}
102	return(0) ;	1✔
103	}
104
105	int var_clear() {	3✔
106	Trick::VariableServerSession * session = get_session();	3✔
107
108	if (session != NULL ) {	3✔
109	session->var_clear() ;	3✔
110	}
111
112	// std::cout << "Done with var_clear" << std::endl;
113	return(0) ;	3✔
114	}
115
116	int var_cycle(double in_rate) {	2✔
117	Trick::VariableServerSession * session = get_session();	2✔
118
119	if (session != NULL ) {	2✔
120	session->var_cycle(in_rate) ;	2✔
121	}
122	return(0) ;	2✔
123	}
124
125	int var_pause() {	×
126	Trick::VariableServerSession * session = get_session();	×
127
128	if (session != NULL ) {	×
129	session->set_pause(true) ;	×
130	}
131	return(0) ;	×
132
133	}
134
135	int var_unpause() {	×
136	Trick::VariableServerSession * session = get_session();	×
137
138	if (session != NULL ) {	×
139	session->set_pause(false) ;	×
140	}
141	return(0) ;	×
142
143	}
144
145	int var_exit() {	4✔
146	Trick::VariableServerSession * session = get_session();	4✔
147
148	if (session != NULL ) {	4✔
149	session->var_exit() ;	4✔
150	}
151	return(0) ;	4✔
152	}
153
154	int var_validate_address(int on_off) {	×
155	Trick::VariableServerSession * session = get_session();	×
156
157	if (session != NULL ) {	×
158	session->var_validate_address((bool)on_off) ;	×
159	}
160	return(0) ;	×
161	}
162
163	int var_debug(int level) {	×
164	Trick::VariableServerSession * session = get_session();	×
165
166	if (session != NULL ) {	×
167	session->var_debug(level) ;	×
168	}
169	return(0) ;	×
170	}
171
172	int var_ascii() {	×
173	Trick::VariableServerSession * session = get_session();	×
174
175	if (session != NULL ) {	×
176	session->var_ascii() ;	×
177	}
178	return(0) ;	×
179	}
180
181	int var_binary() {	×
182	Trick::VariableServerSession * session = get_session();	×
183
184	if (session != NULL ) {	×
185	session->var_binary() ;	×
186	}
187	return(0) ;	×
188	}
189
190	int var_retry_bad_ref() {	×
191	message_publish(MSG_WARNING,"var_retry_bad_ref has been deprecated\n") ;	×
192	return(0) ;	×
193	}
194
195	int var_binary_nonames() {	×
196	Trick::VariableServerSession * session = get_session();	×
197
198	if (session != NULL ) {	×
199	session->var_binary_nonames() ;	×
200	}
201	return(0) ;	×
202	}
203
204	int var_set_copy_mode(int mode) {	×
205	Trick::VariableServerSession * session = get_session();	×
206
207	if (session != NULL ) {	×
208	session->var_set_copy_mode(mode) ;	×
209	if ( mode == VS_COPY_SCHEDULED ) {	×
210	the_vs->get_next_sync_call_time() ;	×
211	the_vs->get_next_freeze_call_time() ;	×
212	}
213	}
214	return 0 ;	×
215	}
216
217	int var_set_write_mode(int mode) {	×
218	Trick::VariableServerSession * session = get_session();	×
219	if (session != NULL ) {	×
220	session->var_set_write_mode(mode) ;	×
221	}
222	return 0 ;	×
223	}
224
225	int var_set_send_stdio(int mode) {	×
226	Trick::VariableServerSession * session = get_session();	×
227	if (session != NULL ) {	×
228	session->set_send_stdio((bool)mode) ;	×
229	}
230	return 0 ;	×
231	}
232
233	int var_sync(int mode) {	×
234	Trick::VariableServerSession * session = get_session();	×
235	if (session != NULL ) {	×
236	session->var_sync(mode) ;	×
237	if ( mode ) {	×
238	the_vs->get_next_sync_call_time() ;	×
239	the_vs->get_next_freeze_call_time() ;	×
240	}
241	}
242	return(0) ;	×
243	}
244
245	int var_set_frame_multiple(unsigned int mult) {	×
246	Trick::VariableServerSession * session = get_session();	×
247	if (session != NULL ) {	×
248	session->var_set_frame_multiple(mult) ;	×
249	}
250	return 0 ;	×
251	}
252
253	int var_set_frame_offset(unsigned int offset) {	×
254	Trick::VariableServerSession * session = get_session();	×
255	if (session != NULL ) {	×
256	session->var_set_frame_offset(offset) ;	×
257	}
258	return 0 ;	×
259	}
260
261	int var_set_freeze_frame_multiple(unsigned int mult) {	×
262	Trick::VariableServerSession * session = get_session();	×
263	if (session != NULL ) {	×
264	session->var_set_freeze_frame_multiple(mult) ;	×
265	}
266	return 0 ;	×
267	}
268
269	int var_set_freeze_frame_offset(unsigned int offset) {	×
270	Trick::VariableServerSession * session = get_session();	×
271	if (session != NULL ) {	×
272	session->var_set_freeze_frame_offset(offset) ;	×
273	}
274	return 0 ;	×
275	}
276
277	int var_byteswap(bool on_off) {	×
278	Trick::VariableServerSession * session = get_session();	×
279	if (session != NULL ) {	×
280	session->var_byteswap(on_off) ;	×
281	}
282	return(0) ;	×
283	}
284
285	int var_write_stdio(int stream , std::string text ) {	1,032✔
286	// std::cout << "Executing var_write_stdio" << std::endl;
287	Trick::VariableServerSession * session = get_session();	1,032✔
288	if (session != NULL and session->get_send_stdio() == true) {	1,032✔
289	session->write_stdio(stream, text) ;	×
290	} else {
291	if ( stream == 1 ) {	1,032✔
292	fprintf( stdout , "%s" , text.c_str() ) ;	1,010✔
293	} else {
294	fprintf( stderr , "%s" , text.c_str() ) ;	22✔
295	}
296	}
297	return(0) ;	1,032✔
298	}
299
300	int var_set_client_tag( std::string text ) {	5✔
301	Trick::VariableServerSessionThread * vst = get_vst();	5✔
302	if (vst != NULL) {	5✔
303
304	vst->set_client_tag(text);	5✔
305
306	#if __linux__
307	#ifdef __GNUC__
308	#if __GNUC__ >= 4 && __GNUC_MINOR__ >= 2
309	std::string short_str = std::string("VS_") + text.substr(0,12) ;	15✔
310	pthread_setname_np(pthread_self(), short_str.c_str()) ;	5✔
311	#endif
312	#endif
313	#endif
314	}
315	return(0) ;	5✔
316	}
317
318	int var_send_list_size() {	1✔
319
320	Trick::VariableServerSession * session = get_session();	1✔
321	if (session != NULL ) {	1✔
322	session->send_list_size() ;	1✔
323	}
324	return(0) ;	1✔
325	}
326
327	int send_sie_resource() {	×
328	Trick::VariableServerSession * session = get_session();	×
329	if (session != NULL ) {	×
330	session->send_sie_resource() ;	×
331	}
332	return 0 ;	×
333	}
334
335	int send_sie_class() {	×
336	Trick::VariableServerSession * session = get_session();	×
337	if (session != NULL ) {	×
338	session->send_sie_class() ;	×
339	}
340	return 0 ;	×
341	}
342
343	int send_sie_enum() {	×
344	Trick::VariableServerSession * session = get_session();	×
345	if (session != NULL ) {	×
346	session->send_sie_enum() ;	×
347	}
348	return 0 ;	×
349	}
350
351	int send_sie_top_level_objects() {	×
352	Trick::VariableServerSession * session = get_session();	×
353	if (session != NULL ) {	×
354	return session->send_sie_top_level_objects() ;	×
355	}
356	return 0 ;	×
357	}
358
359	int send_file(std::string file_name) {	×
360	Trick::VariableServerSession * session = get_session();	×
361	if (session != NULL ) {	×
362	return session->send_file(file_name) ;	×
363	}
364	return 0 ;	×
365	}
366
367
368	// Command to turn on log to playback file
369	int var_server_log_on() {	×
370	Trick::VariableServerSession * session = get_session();	×
371	if (session != NULL ) {	×
372	return session->set_log(true) ;	×
373	}
374	return 0 ;	×
375	}
376
377	// Command to turn off log to playback file
378	int var_server_log_off() {	×
379	Trick::VariableServerSession * session = get_session();	×
380	if (session != NULL ) {	×
381	return session->set_log(false) ;	×
382	}
383	return 0 ;	×
384	}
385
386	// Command to turn on log to playback file
387	int var_server_session_log_on() {	×
388	Trick::VariableServerSession * session = get_session();	×
389	if (session != NULL ) {	×
390	return session->set_session_log(true) ;	×
391	}
392	return 0 ;	×
393	}
394
395	// Command to turn off log to playback file
396	int var_server_session_log_off() {	×
397	Trick::VariableServerSession * session = get_session();	×
398	if (session != NULL ) {	×
399	return session->set_session_log(false) ;	×
400	}
401	return 0 ;	×
402	}
403
404	Trick::VariableServer * var_server_get_var_server() {	×
405	return the_vs ;	×
406	}
407
408	extern "C" void var_server_list_connections(void) {	×
409	std::cout << *the_vs << std::endl;	×
410	}	×
411
412	/**
413	* @relates Trick::VariableServer
414	* @copydoc Trick::VariableServer::get_hostname
415	* C wrapper Trick::VariableServer::get_hostname
416	*/
417	extern "C" const char * var_server_get_hostname(void) {	×
418	const char * ret = (the_vs->get_hostname()) ;	×
419	return ret;	×
420	}
421
422	/**
423	* @relates Trick::VariableServer
424	* @copydoc Trick::VariableServer::get_port
425	* C wrapper Trick::VariableServer::get_port
426	*/
427	extern "C" unsigned short var_server_get_port(void) {	2✔
428	return(the_vs->get_listen_thread().get_port()) ;	2✔
429	}
430
431	/**
432	* @relates Trick::VariableServer
433	* @copydoc Trick::VariableServer::set_port
434	* C wrapper Trick::VariableServer::set_port
435	*/
436	extern "C" void var_server_set_port(unsigned short port) {	1✔
437	the_vs->get_listen_thread().set_port(port);	1✔
438	}	1✔
439
440	/**
441	* @relates Trick::VariableServer
442	* @copydoc Trick::VariableServer::set_listen_socket
443	* C wrapper Trick::VariableServer::set_listen_socket
444	*/
445	extern "C" void var_server_set_source_address(const char * source_address) {	×
446	the_vs->get_listen_thread().set_source_address(source_address) ;	×
447	}	×
448
449	/**
450	* @relates Trick::VariableServer
451	* @copydoc Trick::VariableServer::get_user_tag
452	* C wrapper Trick::VariableServer::get_user_tag
453	*/
454	extern "C" const char * var_server_get_user_tag(void) {	×
455	return(the_vs->get_listen_thread().get_user_tag_ref().c_str()) ;	×
456	}
457
458	/**
459	* @relates Trick::VariableServer
460	* @copydoc Trick::VariableServer::set_user_tag
461	* C wrapper Trick::VariableServer::set_user_tag
462	*/
463	extern "C" void var_server_set_user_tag(const char * in_tag) {	×
464	the_vs->get_listen_thread().set_user_tag(std::string(in_tag));	×
465	}	×
466
467	/**
468	* @relates Trick::VariableServer
469	* @copydoc Trick::VariableServer::get_enabled
470	* C wrapper Trick::VariableServer::get_enabled
471	*/
472	extern "C" int var_server_get_enabled(void) {	×
473	return(the_vs->get_enabled()) ;	×
474	}
475
476	/**
477	* @relates Trick::VariableServer
478	* @copydoc Trick::VariableServer::set_enabled
479	* C wrapper Trick::VariableServer::set_enabled
480	*/
481	extern "C" void var_server_set_enabled(int on_off) {	7✔
482	the_vs->set_enabled((bool)on_off) ;	7✔
483	}	7✔
484
485	/**
486	* @relates Trick::VariableServer
487	* @copydoc Trick::VariableServer::create_udp_socket
488	* C wrapper Trick::VariableServer::create_udp_socket
489	*/
490	extern "C" int var_server_create_tcp_socket(const char * source_address, unsigned short port) {	×
491	the_vs->create_tcp_socket(source_address, port) ;	×
492	return 0 ;	×
493	}
494
495	/**
496	* @relates Trick::VariableServer
497	* @copydoc Trick::VariableServer::create_udp_socket
498	* C wrapper Trick::VariableServer::create_udp_socket
499	*/
500	extern "C" int var_server_create_udp_socket(const char * source_address, unsigned short port) {	×
501	the_vs->create_udp_socket(source_address, port) ;	×
502	return 0 ;	×
503	}
504
505	/**
506	* @relates Trick::VariableServer
507	* @copydoc Trick::VariableServer::create_multicast_socket
508	* C wrapper Trick::VariableServer::create_multicast_socket
509	*/
510	extern "C" int var_server_create_multicast_socket(const char * mcast_address,	×
511	const char * source_address, unsigned short port) {
512	return the_vs->create_multicast_socket(mcast_address, source_address, port) ;	×
513	}
514
515	template<class T>
516	void var_set_value( V_DATA & v_data , T value ) ;
517
518	template<>
519	void var_set_value< double > ( V_DATA & v_data , double value ) {	2✔
520	v_data.value.d = value ;	2✔
521	v_data.type = TRICK_DOUBLE ;	2✔
522	}	2✔
523
524	template<>
525	void var_set_value< long long > ( V_DATA & v_data , long long value ) {	1✔
526	v_data.value.ll = value ;	1✔
527	v_data.type = TRICK_LONG_LONG ;	1✔
528	}	1✔
529
530	template<>
531	void var_set_value< const char * > ( V_DATA & v_data , const char * value ) {	1✔
532	v_data.value.cp = (char *)value ;	1✔
533	v_data.type = TRICK_STRING ;	1✔
534	}	1✔
535
536	template<>
537	void var_set_value< void * > ( V_DATA & v_data , void * value ) {	1✔
538	v_data.value.vp = value ;	1✔
539	v_data.type = TRICK_VOID_PTR ;	1✔
540	}	1✔
541
542	template<class T>
543	int var_set_base( const char * var , T value , const char * units ) {	5✔
544	REF2 *ref = ref_attributes(var) ;	5✔
545	if ( ref != NULL ) {	5✔
546	if (ref->attr->io & TRICK_VAR_INPUT) {	5✔
547	V_TREE v_tree ;
548	V_DATA v_data ;
549	v_tree.v_data = &v_data ;	5✔
550	var_set_value( v_data , value) ;	5✔
551	if ( units != NULL ) {	5✔
552	ref->units = strdup(map_trick_units_to_udunits(units).c_str()) ;	1✔
553	} else {
554	ref->units = NULL ;	4✔
555	}
556	ref_assignment(ref , &v_tree) ;	5✔
557
558	// Free allocated memory within a REF2 structure. Does not free the REF2 itself
559	ref_free(ref) ;	5✔
560
561	// Free the REF2 structure itself
562	free(ref) ;	5✔
563	ref = NULL;	5✔
564	} else {
565	message_publish(MSG_WARNING,"Cannot assign to %s because io_spec does not allow input\n", var) ;	×
566	return 1;	×
567	}
568	} else {
569	message_publish(MSG_WARNING,"reference attributes not found for variable %s in call to var_set\n", var) ;	×
570	return 2;	×
571	}
572	return 0 ;	5✔
573	}
574
575	int var_set( const char * var , double value , const char * units ) {	2✔
576	return var_set_base(var, value, units) ;	2✔
577	}
578
579	int var_set( const char * var , long long value , const char * units ) {	1✔
580	return var_set_base(var, value, units) ;	1✔
581	}
582
583	int var_set( const char * var , const char * value , const char * units ) {	1✔
584	return var_set_base(var, value, units) ;	1✔
585	}
586
587	int var_set( const char * var , void * value , const char * units ) {	1✔
588	return var_set_base(var, value, units) ;	1✔
589	}
590
591	void var_allow_connections() {	7✔
592	var_server_set_enabled(true) ;	7✔
593	the_vs->set_allow_connections(true) ;	7✔
594	}	7✔
595
NEW 596	void var_disable_connections() {	×
NEW 597	var_server_set_enabled(false) ;	×
NEW 598	the_vs->set_allow_connections(false) ;	×
NEW 599	}	×
600
601	void var_allow_all_connections() {	1✔
602	var_allow_connections() ;	1✔
603	the_vs->set_bypass_ip_check(true) ;	1✔
604	}	1✔
605
606	void var_resolve_hostname() {	6✔
607	the_vs->resolve_hostname() ;	6✔
608	}	6✔
609
NEW 610	bool var_set_allow_connections(bool b) {	×
NEW 611	return the_vs->set_allow_connections(b) ;	×
612	}
613
NEW 614	bool var_get_allow_connections() {	×
NEW 615	return the_vs->get_allow_connections() ;	×
616	}
617
NEW 618	int var_set_ip_check_bypass(bool b) {	×
NEW 619	return the_vs->set_bypass_ip_check(b) ;	×
620	}
621
NEW 622	int var_get_ip_check_bypass() {	×
NEW 623	return the_vs->get_bypass_ip_check() ;	×
624	}
625
NEW 626	void var_add_ip(const std::string& ip) {	×
NEW 627	the_vs->add_ip(ip) ;	×
NEW 628	}	×
629
NEW 630	void var_remove_ip(const std::string& ip) {	×
NEW 631	the_vs->remove_ip(ip) ;	×
NEW 632	}	×

nasa / trick / 25441446766

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous