void rail_send_client_get_appid_req_order(rdpRailOrder* rail_order);
void rail_send_client_langbar_info_order(rdpRailOrder* rail_order);
-rdpRailOrder* rail_order_new();
+rdpRailOrder* rail_order_new(void);
void rail_order_free(rdpRailOrder* rail_order);
#endif /* __RAIL_ORDERS_H */
};
-ISOCH_CALLBACK_QUEUE* isoch_queue_new();
+ISOCH_CALLBACK_QUEUE* isoch_queue_new(void);
};
-REQUEST_QUEUE* request_queue_new();
+REQUEST_QUEUE* request_queue_new(void);
#endif /* __REQUEST_QUEUE_H */
ANDROID_EVENT_KEY* android_event_key_new(int flags, UINT16 scancode);
ANDROID_EVENT_KEY* android_event_unicodekey_new(UINT16 key);
ANDROID_EVENT_CURSOR* android_event_cursor_new(UINT16 flags, UINT16 x, UINT16 y);
-ANDROID_EVENT* android_event_disconnect_new();
+ANDROID_EVENT* android_event_disconnect_new(void);
void android_event_key_free(ANDROID_EVENT_KEY* event);
void android_event_unicodekey_free(ANDROID_EVENT_KEY* event);
void android_event_cursor_free(ANDROID_EVENT_CURSOR* event);
jint init_callback_environment(JavaVM* vm);
jboolean jni_attach_thread(JNIEnv** env);
-void jni_detach_thread();
+void jni_detach_thread(void);
void freerdp_callback(const char * callback, const char * signature, ...);
jboolean freerdp_callback_bool_result(const char * callback, const char * signature, ...);
void tsxconnect_callback(const char * callback, const char * signature, ...);
#include "dfreerdp.h"
-void df_keyboard_init();
+void df_keyboard_init(void);
BOOL df_event_process(freerdp* instance, DFBEvent* event);
#endif /* __DF_EVENT_H */
@property (assign) IBOutlet NSWindow *window;
-int rdp_connect();
+int rdp_connect(void);
@end
void pointer_set(rdpContext* context, rdpPointer* pointer);
void pointer_setNull(rdpContext* context);
void pointer_setDefault(rdpContext* context);
-int rdp_connect();
+int rdp_connect(void);
BOOL mac_pre_connect(freerdp *inst);
BOOL mac_post_connect(freerdp *inst);
void mac_context_new(freerdp *inst, rdpContext *context);
void mac_on_free_rail_client_event(RDP_EVENT* event);
void mac_process_rail_server_sysparam_event(rdpChannels* channels, RDP_EVENT* event);
void mac_process_rail_exec_result_event(rdpChannels* channels, RDP_EVENT* event);
-void mac_rail_enable_remoteapp_mode();
+void mac_rail_enable_remoteapp_mode(void);
void mac_process_rail_server_minmaxinfo_event(rdpChannels* channels, RDP_EVENT* event);
void mac_process_rail_server_localmovesize_event(freerdp *inst, RDP_EVENT *event);
void apple_center_window(NSRect * r);
extern "C" {
#endif
-FREERDP_API LPSTR freerdp_get_library_install_path();
-FREERDP_API LPSTR freerdp_get_dynamic_addin_install_path();
+FREERDP_API LPSTR freerdp_get_library_install_path(void);
+FREERDP_API LPSTR freerdp_get_dynamic_addin_install_path(void);
FREERDP_API int freerdp_register_addin_provider(FREERDP_LOAD_CHANNEL_ADDIN_ENTRY_FN provider, DWORD dwFlags);
FREERDP_API int freerdp_client_parse_command_line_arguments(int argc, char** argv, rdpSettings* settings);
FREERDP_API int freerdp_client_load_addins(rdpChannels* channels, rdpSettings* settings);
-FREERDP_API int freerdp_client_print_version();
+FREERDP_API int freerdp_client_print_version(void);
FREERDP_API int freerdp_client_print_command_line_help(int argc, char** argv);
FREERDP_API int freerdp_parse_username(char* username, char** user, char** domain);
FREERDP_API BOOL freerdp_client_parse_rdp_file_buffer(rdpFile* file, BYTE* buffer, size_t size);
FREERDP_API BOOL freerdp_client_populate_settings_from_rdp_file(rdpFile* file, rdpSettings* settings);
-FREERDP_API rdpFile* freerdp_client_rdp_file_new();
+FREERDP_API rdpFile* freerdp_client_rdp_file_new(void);
FREERDP_API void freerdp_client_rdp_file_free(rdpFile* file);
#ifdef __cplusplus
FREERDP_API void freerdp_get_version(int* major, int* minor, int* revision);
-FREERDP_API freerdp* freerdp_new();
+FREERDP_API freerdp* freerdp_new(void);
FREERDP_API void freerdp_free(freerdp* instance);
#ifdef __cplusplus
#include <freerdp/api.h>
#include <freerdp/gdi/gdi.h>
-FREERDP_API HGDI_DC gdi_GetDC();
+FREERDP_API HGDI_DC gdi_GetDC(void);
FREERDP_API HGDI_DC gdi_CreateDC(HCLRCONV clrconv, int bpp);
FREERDP_API HGDI_DC gdi_CreateCompatibleDC(HGDI_DC hdc);
FREERDP_API HGDIOBJECT gdi_SelectObject(HGDI_DC hdc, HGDIOBJECT hgdiobject);
#include <freerdp/gdi/gdi.h>
FREERDP_API HGDI_PALETTE gdi_CreatePalette(HGDI_PALETTE palette);
-FREERDP_API HGDI_PALETTE gdi_GetSystemPalette();
+FREERDP_API HGDI_PALETTE gdi_GetSystemPalette(void);
#endif /* FREERDP_GDI_PALETTE_H */
#define YORUBA 0x046A
#define ZULU 0x0435
-FREERDP_API UINT32 freerdp_get_system_locale_id();
-FREERDP_API UINT32 freerdp_detect_keyboard_layout_from_system_locale();
+FREERDP_API UINT32 freerdp_get_system_locale_id(void);
+FREERDP_API UINT32 freerdp_detect_keyboard_layout_from_system_locale(void);
FREERDP_API const char* freerdp_get_system_locale_name_from_id(UINT32 localeId);
#endif /* FREERDP_LOCALE_H */
FREERDP_API int msusb_msinterface_write(MSUSB_INTERFACE_DESCRIPTOR* MsInterface, BYTE* data, int* offset);
/* MSUSB_CONFIG exported functions */
-FREERDP_API MSUSB_CONFIG_DESCRIPTOR* msusb_msconfig_new();
+FREERDP_API MSUSB_CONFIG_DESCRIPTOR* msusb_msconfig_new(void);
FREERDP_API void msusb_msconfig_free(MSUSB_CONFIG_DESCRIPTOR* MsConfig);
FREERDP_API MSUSB_CONFIG_DESCRIPTOR* msusb_msconfig_read(BYTE* data, UINT32 data_size, UINT32 NumInterfaces);
FREERDP_API int msusb_msconfig_write(MSUSB_CONFIG_DESCRIPTOR* MsConfg, BYTE* data, int * offset);
FREERDP_API void profiler_enter(PROFILER* profiler);
FREERDP_API void profiler_exit(PROFILER* profiler);
-FREERDP_API void profiler_print_header();
+FREERDP_API void profiler_print_header(void);
FREERDP_API void profiler_print(PROFILER* profiler);
-FREERDP_API void profiler_print_footer();
+FREERDP_API void profiler_print_footer(void);
#ifdef __cplusplus
}
extern "C" {
#endif
-FREERDP_API STOPWATCH* stopwatch_create();
+FREERDP_API STOPWATCH* stopwatch_create(void);
FREERDP_API void stopwatch_free(STOPWATCH* stopwatch);
FREERDP_API void stopwatch_start(STOPWATCH* stopwatch);
FREERDP_API int freerdp_tcp_set_no_delay(int sockfd, BOOL no_delay);
-FREERDP_API int freerdp_wsa_startup();
-FREERDP_API int freerdp_wsa_cleanup();
+FREERDP_API int freerdp_wsa_startup(void);
+FREERDP_API int freerdp_wsa_cleanup(void);
#ifdef __cplusplus
}
extern "C" {
#endif
-FREERDP_API UINT64 freerdp_windows_gmtime();
+FREERDP_API UINT64 freerdp_windows_gmtime(void);
FREERDP_API UINT64 freerdp_get_windows_time_from_unix_time(time_t unix_time);
FREERDP_API time_t freerdp_get_unix_time_from_windows_time(UINT64 windows_time);
BOOL certificate_read_server_x509_certificate_chain(rdpCertificate* certificate, STREAM* s);
int certificate_read_server_certificate(rdpCertificate* certificate, BYTE* server_cert, int length);
-rdpCertificate* certificate_new();
+rdpCertificate* certificate_new(void);
void certificate_free(rdpCertificate* certificate);
rdpRsaKey* key_new(const char *keyfile);
void http_context_set_connection(HttpContext* http_context, char* connection);
void http_context_set_pragma(HttpContext* http_context, char* pragma);
-HttpContext* http_context_new();
+HttpContext* http_context_new(void);
void http_context_free(HttpContext* http_context);
struct _http_request
wStream* http_request_write(HttpContext* http_context, HttpRequest* http_request);
-HttpRequest* http_request_new();
+HttpRequest* http_request_new(void);
void http_request_free(HttpRequest* http_request);
struct _http_response
HttpResponse* http_response_recv(rdpTls* tls);
-HttpResponse* http_response_new();
+HttpResponse* http_response_new(void);
void http_response_free(HttpResponse* http_response);
#endif /* FREERDP_CORE_HTTP_H */
void rpc_ntlm_http_init_channel(rdpRpc* rpc, rdpNtlmHttp* ntlm_http, TSG_CHANNEL channel);
-rdpNtlmHttp* ntlm_http_new();
+rdpNtlmHttp* ntlm_http_new(void);
void ntlm_http_free(rdpNtlmHttp* ntlm_http);
#endif
BOOL ntlm_client_make_spn(rdpNtlm* ntlm, LPCTSTR ServiceClass, char* hostname);
-rdpNtlm* ntlm_new();
+rdpNtlm* ntlm_new(void);
void ntlm_free(rdpNtlm* ntlm);
#endif /* FREERDP_CORE_NTLM_H */
void license_encrypt_premaster_secret(rdpLicense* license);
void license_decrypt_platform_challenge(rdpLicense* license);
-PRODUCT_INFO* license_new_product_info();
+PRODUCT_INFO* license_new_product_info(void);
void license_free_product_info(PRODUCT_INFO* productInfo);
BOOL license_read_product_info(STREAM* s, PRODUCT_INFO* productInfo);
BOOL license_read_binary_blob(STREAM* s, LICENSE_BLOB* blob);
void license_write_binary_blob(STREAM* s, LICENSE_BLOB* blob);
-SCOPE_LIST* license_new_scope_list();
+SCOPE_LIST* license_new_scope_list(void);
void license_free_scope_list(SCOPE_LIST* scopeList);
BOOL license_read_scope_list(STREAM* s, SCOPE_LIST* scopeList);
BOOL rdp_recv_redirection_packet(rdpRdp* rdp, STREAM* s);
BOOL rdp_recv_enhanced_security_redirection_packet(rdpRdp* rdp, STREAM* s);
-rdpRedirection* redirection_new();
+rdpRedirection* redirection_new(void);
void redirection_free(rdpRedirection* redirection);
#ifdef WITH_DEBUG_REDIR
mfEvent* mf_event_new(int type);
void mf_event_free(mfEvent* event);
-mfEventQueue* mf_event_queue_new();
+mfEventQueue* mf_event_queue_new(void);
void mf_event_queue_free(mfEventQueue* event_queue);
-#endif /* __MF_EVENT_H */
\ No newline at end of file
+#endif /* __MF_EVENT_H */
int mf_info_try_lock(mfInfo* mfi, UINT32 ms);\r
int mf_info_unlock(mfInfo* mfi);\r
\r
-mfInfo* mf_info_get_instance();\r
+mfInfo* mf_info_get_instance(void);\r
void mf_info_peer_register(mfInfo* mfi, mfPeerContext* context);\r
void mf_info_peer_unregister(mfInfo* mfi, mfPeerContext* context);\r
\r
void mf_info_getScreenData(mfInfo* mfi, long* width, long* height, BYTE** pBits, int* pitch);\r
//BOOL CALLBACK mf_info_monEnumCB(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData);\r
\r
-#endif /* mf_info_H */
\ No newline at end of file
+#endif /* mf_info_H */\r
int mf_mlion_display_info(UINT32* disp_width, UINT32* dispHeight, UINT32* scale);
-int mf_mlion_screen_updates_init();
+int mf_mlion_screen_updates_init(void);
-int mf_mlion_start_getting_screen_updates();
-int mf_mlion_stop_getting_screen_updates();
+int mf_mlion_start_getting_screen_updates(void);
+int mf_mlion_stop_getting_screen_updates(void);
int mf_mlion_get_dirty_region(RFX_RECT* invalid);
int mf_mlion_peek_dirty_region(RFX_RECT* invalid);
-int mf_mlion_clear_dirty_region();
+int mf_mlion_clear_dirty_region(void);
int mf_mlion_get_pixelData(long x, long y, long width, long height, BYTE **pxData);
-#endif
\ No newline at end of file
+#endif
typedef struct _AQRecorderState AQRecorderState;\r
\r
BOOL mf_peer_rdpsnd_init(mfPeerContext* context);\r
-BOOL mf_peer_rdpsnd_stop();\r
+BOOL mf_peer_rdpsnd_stop(void);\r
\r
#endif /* MF_RDPSND_H */\r
\r
int wf_info_try_lock(wfInfo* wfi, DWORD dwMilliseconds);\r
int wf_info_unlock(wfInfo* wfi);\r
\r
-wfInfo* wf_info_get_instance();\r
+wfInfo* wf_info_get_instance(void);\r
void wf_info_peer_register(wfInfo* wfi, wfPeerContext* context);\r
void wf_info_peer_unregister(wfInfo* wfi, wfPeerContext* context);\r
\r
void wf_info_getScreenData(wfInfo* wfi, long* width, long* height, BYTE** pBits, int* pitch);\r
BOOL CALLBACK wf_info_monEnumCB(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData);\r
\r
-#endif /* WF_INFO_H */
\ No newline at end of file
+#endif /* WF_INFO_H */\r
FREERDP_API BOOL wfreerdp_server_start(wfServer* server);
FREERDP_API BOOL wfreerdp_server_stop(wfServer* server);
-FREERDP_API wfServer* wfreerdp_server_new();
+FREERDP_API wfServer* wfreerdp_server_new(void);
FREERDP_API void wfreerdp_server_free(wfServer* server);
FREERDP_API BOOL wfreerdp_server_is_running(wfServer* server);
-FREERDP_API UINT32 wfreerdp_server_num_peers();
+FREERDP_API UINT32 wfreerdp_server_num_peers(void);
FREERDP_API UINT32 wfreerdp_server_get_peer_hostname(int pId, wchar_t * dstStr);
FREERDP_API BOOL wfreerdp_server_peer_is_local(int pId);
FREERDP_API BOOL wfreerdp_server_peer_is_connected(int pId);
void wf_peer_synchronize_event(rdpInput* input, UINT32 flags);\r
\r
void wf_peer_send_changes(freerdp_peer* client);\r
-
-void wf_detect_win_ver();\r
-
+\r
+void wf_detect_win_ver(void);\r
+\r
void wf_peer_accepted(freerdp_listener* instance, freerdp_peer* client);\r
\r
DWORD WINAPI wf_peer_main_loop(LPVOID lpParam);\r
-
+\r
\r
#endif /* WF_PEER_H */\r
#include "wf_interface.h"
-int wf_rdpsnd_lock();
-int wf_rdpsnd_unlock();
+int wf_rdpsnd_lock(void);
+int wf_rdpsnd_unlock(void);
BOOL wf_peer_rdpsnd_init(wfPeerContext* context);
DWORD WINAPI wf_rdpsnd_thread(LPVOID lpParam);
xfEvent* xf_event_new(int type);
void xf_event_free(xfEvent* event);
-xfEventQueue* xf_event_queue_new();
+xfEventQueue* xf_event_queue_new(void);
void xf_event_queue_free(xfEventQueue* event_queue);
#endif /* __XF_EVENT_H */
WINPR_API int MessageQueue_Get(wMessageQueue* queue, wMessage* message);
WINPR_API int MessageQueue_Peek(wMessageQueue* queue, wMessage* message, BOOL remove);
-WINPR_API wMessageQueue* MessageQueue_New();
+WINPR_API wMessageQueue* MessageQueue_New(void);
WINPR_API void MessageQueue_Free(wMessageQueue* queue);
#endif /* WINPR_COLLECTIONS_H */
/* Clean-up Group */
-WINPR_API PTP_CLEANUP_GROUP CreateThreadpoolCleanupGroup();
+WINPR_API PTP_CLEANUP_GROUP CreateThreadpoolCleanupGroup(void);
WINPR_API VOID CloseThreadpoolCleanupGroupMembers(PTP_CLEANUP_GROUP ptpcg, BOOL fCancelPendingCallbacks, PVOID pvCleanupContext);
WINPR_API VOID CloseThreadpoolCleanupGroup(PTP_CLEANUP_GROUP ptpcg);
/* Dummy */
-WINPR_API void winpr_pool_dummy();
+WINPR_API void winpr_pool_dummy(void);
#endif /* WINPR_POOL_H */
WINPR_API RPC_STATUS RpcServerUseProtseqIfExA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqIfW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqIfExW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy);
-WINPR_API void RpcServerYield();
+WINPR_API void RpcServerYield(void);
WINPR_API RPC_STATUS RpcMgmtStatsVectorFree(RPC_STATS_VECTOR** StatsVector);
WINPR_API RPC_STATUS RpcMgmtInqStats(RPC_BINDING_HANDLE Binding, RPC_STATS_VECTOR** Statistics);
WINPR_API RPC_STATUS RpcMgmtIsServerListening(RPC_BINDING_HANDLE Binding);
WINPR_API RPC_STATUS RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle);
WINPR_API RPC_STATUS RpcRevertToSelfEx(RPC_BINDING_HANDLE BindingHandle);
-WINPR_API RPC_STATUS RpcRevertToSelf();
+WINPR_API RPC_STATUS RpcRevertToSelf(void);
WINPR_API RPC_STATUS RpcBindingInqAuthClientA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingInqAuthClientW(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
WINPR_API RPC_STATUS RpcBindingServerFromClient(RPC_BINDING_HANDLE ClientBinding, RPC_BINDING_HANDLE* ServerBinding);
WINPR_API DECLSPEC_NORETURN void RpcRaiseException(RPC_STATUS exception);
-WINPR_API RPC_STATUS RpcTestCancel();
+WINPR_API RPC_STATUS RpcTestCancel(void);
WINPR_API RPC_STATUS RpcServerTestCancel(RPC_BINDING_HANDLE BindingHandle);
WINPR_API RPC_STATUS RpcCancelThread(void* Thread);
WINPR_API RPC_STATUS RpcCancelThreadEx(void* Thread, long Timeout);
/* Custom API */
-WINPR_API void sspi_GlobalInit();
-WINPR_API void sspi_GlobalFinish();
+WINPR_API void sspi_GlobalInit(void);
+WINPR_API void sspi_GlobalFinish(void);
WINPR_API void sspi_SecBufferAlloc(PSecBuffer SecBuffer, size_t size);
WINPR_API void sspi_SecBufferFree(PSecBuffer SecBuffer);
#ifndef _WIN32
-PTP_POOL GetDefaultThreadpool();
-PTP_CALLBACK_ENVIRON GetDefaultThreadpoolEnvironment();
+PTP_POOL GetDefaultThreadpool(void);
+PTP_CALLBACK_ENVIRON GetDefaultThreadpoolEnvironment(void);
#endif
};
typedef struct _CREDSSP_CONTEXT CREDSSP_CONTEXT;
-CREDSSP_CONTEXT* credssp_ContextNew();
+CREDSSP_CONTEXT* credssp_ContextNew(void);
void credssp_ContextFree(CREDSSP_CONTEXT* context);
#endif /* WINPR_SSPI_CREDSSP_PRIVATE_H */
};
typedef struct _NTLM_CONTEXT NTLM_CONTEXT;
-NTLM_CONTEXT* ntlm_ContextNew();
+NTLM_CONTEXT* ntlm_ContextNew(void);
void ntlm_ContextFree(NTLM_CONTEXT* context);
#ifdef WITH_DEBUG_NLA
};
typedef struct _NEGOTIATE_CONTEXT NEGOTIATE_CONTEXT;
-NEGOTIATE_CONTEXT* negotiate_ContextNew();
+NEGOTIATE_CONTEXT* negotiate_ContextNew(void);
void negotiate_ContextFree(NEGOTIATE_CONTEXT* context);
#endif /* WINPR_SSPI_NEGOTIATE_PRIVATE_H */
};
typedef struct _SCHANNEL_CONTEXT SCHANNEL_CONTEXT;
-SCHANNEL_CONTEXT* schannel_ContextNew();
+SCHANNEL_CONTEXT* schannel_ContextNew(void);
void schannel_ContextFree(SCHANNEL_CONTEXT* context);
#endif /* WINPR_SSPI_SCHANNEL_PRIVATE_H */
SECURITY_STATUS schannel_openssl_encrypt_message(SCHANNEL_OPENSSL* context, PSecBufferDesc pMessage);
SECURITY_STATUS schannel_openssl_decrypt_message(SCHANNEL_OPENSSL* context, PSecBufferDesc pMessage);
-SCHANNEL_OPENSSL* schannel_openssl_new();
+SCHANNEL_OPENSSL* schannel_openssl_new(void);
void schannel_openssl_free(SCHANNEL_OPENSSL* context);
#endif /* WINPR_SSPI_SCHANNEL_OPENSSL_H */
};
typedef struct _CREDENTIALS CREDENTIALS;
-CREDENTIALS* sspi_CredentialsNew();
+CREDENTIALS* sspi_CredentialsNew(void);
void sspi_CredentialsFree(CREDENTIALS* credentials);
PSecBuffer sspi_FindSecBuffer(PSecBufferDesc pMessage, ULONG BufferType);
-SecHandle* sspi_SecureHandleAlloc();
+SecHandle* sspi_SecureHandleAlloc(void);
void sspi_SecureHandleInit(SecHandle* handle);
void sspi_SecureHandleInvalidate(SecHandle* handle);
void* sspi_SecureHandleGetLowerPointer(SecHandle* handle);