/**
* Allocates a client's TLS credentials and shakes hands through the network.
* This is a blocking network operation.
*
* @param fd stream socket through which to establish the secure communication
* layer.
* @param psz_hostname Server Name Indication to pass to the server, or NULL.
*
* @return NULL on error.
**/
vlc_tls_t *
vlc_tls_ClientCreate (vlc_object_t *obj, int fd, const char *hostname)
{
vlc_tls_t *cl = vlc_custom_create (obj, sizeof (*cl), "tls client");
if (unlikely(cl == NULL))
return NULL;
cl->u.module = vlc_module_load (cl, "tls client", NULL, false,
tls_client_start, cl, fd, hostname);
if (cl->u.module == NULL)
{
msg_Err (cl, "TLS client plugin not available");
vlc_object_release (cl);
return NULL;
}
/* TODO: do this directly in the TLS plugin */
int val;
do
val = cl->handshake (cl);
while (val > 0);
if (val != 0)
{
msg_Err (cl, "TLS client session handshake error");
vlc_module_unload (cl->u.module, tls_client_stop, cl);
vlc_object_release (cl);
return NULL;
}
msg_Dbg (cl, "TLS client session initialized");
return cl;
}
/**
* Initializes the messages logging subsystem and drain the early messages to
* the configured log.
*
* \return 0 on success, -1 on error.
*/
int vlc_LogInit(libvlc_int_t *vlc)
{
vlc_logger_t *logger = libvlc_priv(vlc)->logger;
if (unlikely(logger == NULL))
return -1;
vlc_log_cb cb;
void *sys, *early_sys = NULL;
/* TODO: module configuration item */
module_t *module = vlc_module_load(logger, "logger", NULL, false,
vlc_logger_load, logger, &cb, &sys);
if (module == NULL)
cb = vlc_vaLogDiscard;
vlc_rwlock_wrlock(&logger->lock);
if (logger->log == vlc_vaLogEarly)
early_sys = logger->sys;
logger->log = cb;
logger->sys = sys;
assert(logger->module == NULL); /* Only one call to vlc_LogInit()! */
logger->module = module;
vlc_rwlock_unlock(&logger->lock);
if (early_sys != NULL)
vlc_LogEarlyClose(logger, early_sys);
return 0;
}
vout_window_t *vout_window_New(vlc_object_t *obj,
const char *module,
const vout_window_cfg_t *cfg)
{
window_t *w = vlc_custom_create(obj, sizeof(*w), "window");
vout_window_t *window = &w->wnd;
memset(&window->handle, 0, sizeof(window->handle));
window->control = NULL;
window->sys = NULL;
window->type = cfg->type;
const char *type;
switch (cfg->type) {
#if defined(_WIN32) || defined(__OS2__)
case VOUT_WINDOW_TYPE_HWND:
type = "vout window hwnd";
window->handle.hwnd = NULL;
break;
#endif
#ifdef __APPLE__
case VOUT_WINDOW_TYPE_NSOBJECT:
type = "vout window nsobject";
window->handle.nsobject = NULL;
break;
#endif
case VOUT_WINDOW_TYPE_XID:
type = "vout window xid";
window->handle.xid = 0;
window->display.x11 = NULL;
break;
case VOUT_WINDOW_TYPE_ANDROID_NATIVE:
type = "vout window anative";
window->handle.anativewindow = NULL;
break;
default:
assert(0);
}
w->module = vlc_module_load(window, type, module, module && *module,
vout_window_start, window, cfg);
if (!w->module) {
vlc_object_release(window);
return NULL;
}
/* Hook for screensaver inhibition */
if (var_InheritBool(obj, "disable-screensaver") &&
cfg->type == VOUT_WINDOW_TYPE_XID) {
w->inhibit = vlc_inhibit_Create(VLC_OBJECT (window));
if (w->inhibit != NULL)
vlc_inhibit_Set(w->inhibit, VLC_INHIBIT_VIDEO);
/* FIXME: ^ wait for vout activation, pause */
}
else
w->inhibit = NULL;
return window;
}
/**
* Allocates a client's TLS credentials and shakes hands through the network.
* This is a blocking network operation.
*
* @param fd stream socket through which to establish the secure communication
* layer.
* @param psz_hostname Server Name Indication to pass to the server, or NULL.
*
* @return NULL on error.
**/
vlc_tls_t *
vlc_tls_ClientCreate (vlc_object_t *obj, int fd, const char *hostname)
{
vlc_tls_t *cl = vlc_custom_create (obj, sizeof (*cl), "tls client");
if (unlikely(cl == NULL))
return NULL;
cl->u.module = vlc_module_load (cl, "tls client", NULL, false,
tls_client_start, cl, fd, hostname);
if (cl->u.module == NULL)
{
msg_Err (cl, "TLS client plugin not available");
vlc_object_release (cl);
return NULL;
}
mtime_t deadline = mdate ();
deadline += var_InheritInteger (obj, "ipv4-timeout") * 1000;
struct pollfd ufd[1];
ufd[0].fd = fd;
int val;
while ((val = cl->handshake (cl)) > 0)
{
mtime_t now = mdate ();
if (now > deadline)
now = deadline;
assert (val <= 2);
ufd[0] .events = (val == 1) ? POLLIN : POLLOUT;
if (poll (ufd, 1, (deadline - now) / 1000) == 0)
{
msg_Err (cl, "TLS client session handshake timeout");
val = -1;
break;
}
}
if (val != 0)
{
msg_Err (cl, "TLS client session handshake error");
vlc_module_unload (cl->u.module, tls_client_stop, cl);
vlc_object_release (cl);
return NULL;
}
msg_Dbg (cl, "TLS client session initialized");
return cl;
}
/**
* Allocates TLS credentials for a client.
* Credentials can be cached and reused across multiple TLS sessions.
*
* @return TLS credentials object, or NULL on error.
**/
vlc_tls_creds_t *vlc_tls_ClientCreate (vlc_object_t *obj)
{
vlc_tls_creds_t *crd = vlc_custom_create (obj, sizeof (*crd),
"tls client");
if (unlikely(crd == NULL))
return NULL;
crd->module = vlc_module_load (crd, "tls client", NULL, false,
tls_client_load, crd);
if (crd->module == NULL)
{
msg_Err (crd, "TLS client plugin not available");
vlc_object_release (crd);
return NULL;
}
return crd;
}
/**
* Allocates a whole server's TLS credentials.
*
* @param cert_path required (Unicode) path to an x509 certificate,
* if NULL, anonymous key exchange will be used.
* @param key_path (UTF-8) path to the PKCS private key for the certificate,
* if NULL; cert_path will be used.
*
* @return NULL on error.
*/
vlc_tls_creds_t *
vlc_tls_ServerCreate (vlc_object_t *obj, const char *cert_path,
const char *key_path)
{
vlc_tls_creds_t *srv = vlc_custom_create (obj, sizeof (*srv),
"tls server");
if (unlikely(srv == NULL))
return NULL;
if (key_path == NULL)
key_path = cert_path;
srv->module = vlc_module_load (srv, "tls server", NULL, false,
tls_server_load, srv, cert_path, key_path);
if (srv->module == NULL)
{
msg_Err (srv, "TLS server plugin not available");
vlc_object_release (srv);
return NULL;
}
return srv;
}
vout_window_t *vout_window_New(vlc_object_t *obj, const char *module,
const vout_window_cfg_t *cfg,
const vout_window_owner_t *owner)
{
window_t *w = vlc_custom_create(obj, sizeof(*w), "window");
vout_window_t *window = &w->wnd;
memset(&window->handle, 0, sizeof(window->handle));
window->control = NULL;
window->sys = NULL;
if (owner != NULL)
window->owner = *owner;
else
window->owner.resized = NULL;
w->module = vlc_module_load(window, "vout window", module,
module && *module,
vout_window_start, window, cfg);
if (!w->module) {
vlc_object_release(window);
return NULL;
}
/* Hook for screensaver inhibition */
if (var_InheritBool(obj, "disable-screensaver") &&
window->type == VOUT_WINDOW_TYPE_XID) {
w->inhibit = vlc_inhibit_Create(VLC_OBJECT (window));
if (w->inhibit != NULL)
vlc_inhibit_Set(w->inhibit, VLC_INHIBIT_VIDEO);
/* FIXME: ^ wait for vout activation, pause */
}
else
w->inhibit = NULL;
return window;
}
