/**
* Allocate a new collection of the given type.
* The pointer will have to be deallocated using #xmmsv_coll_unref.
*
* @param type the #xmmsv_coll_type_t specifying the type of collection to create.
* @return a pointer to the newly created collection, or NULL if the type is invalid.
*/
static xmmsv_coll_internal_t*
_xmmsv_coll_new (xmmsv_coll_type_t type)
{
xmmsv_coll_internal_t *coll;
x_return_val_if_fail (type <= XMMS_COLLECTION_TYPE_LAST, NULL);
coll = x_new0 (xmmsv_coll_internal_t, 1);
if (!coll) {
x_oom ();
return NULL;
}
coll->type = type;
coll->idlist = xmmsv_new_list ();
xmmsv_list_restrict_type (coll->idlist, XMMSV_TYPE_INT64);
coll->operands = xmmsv_new_list ();
xmmsv_list_restrict_type (coll->operands, XMMSV_TYPE_COLL);
coll->attributes = xmmsv_new_dict ();
return coll;
}
xmmsc_result_t *
xmmsc_visualization_init (xmmsc_connection_t *c)
{
xmmsc_result_t *res = NULL;
x_check_conn (c, 0);
c->visc++;
c->visv = realloc (c->visv, sizeof (xmmsc_visualization_t*) * c->visc);
if (!c->visv) {
x_oom ();
c->visc = 0;
}
if (c->visc > 0) {
int vv = c->visc-1;
if (!(c->visv[vv] = x_new0 (xmmsc_visualization_t, 1))) {
x_oom ();
} else {
c->visv[vv]->idx = vv;
c->visv[vv]->state = VIS_NEW;
res = xmmsc_send_msg_no_arg (c, XMMS_IPC_OBJECT_VISUALIZATION, XMMS_IPC_CMD_VISUALIZATION_REGISTER);
if (res) {
xmmsc_result_visc_set (res, c->visv[vv]);
}
}
}
return res;
}
xmmsc_connection_t *
xmmsc_init (const char *clientname)
{
xmmsc_connection_t *c;
int i = 0;
char j;
x_api_error_if (!clientname, "with NULL clientname", NULL);
if (!(c = x_new0 (xmmsc_connection_t, 1))) {
return NULL;
}
while (clientname[i]) {
j = clientname[i];
if (!isalnum (j) && j != '_' && j != '-') {
/* snyggt! */
free (c);
x_api_error_if (true, "clientname contains invalid chars, just alphanumeric chars are allowed!", NULL);
}
i++;
}
if (!(c->clientname = strdup (clientname))) {
free (c);
return NULL;
}
c->visc = 0;
c->visv = NULL;
return xmmsc_ref (c);
}
xmms_ipc_transport_t *
xmms_ipc_usocket_server_init (const xmms_url_t *url)
{
int fd;
int flags;
xmms_ipc_transport_t *ipct;
struct sockaddr_un saddr;
fd = socket (AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) {
return NULL;
}
saddr.sun_family = AF_UNIX;
snprintf (saddr.sun_path, sizeof (saddr.sun_path), "/%s", url->path);
if (access (saddr.sun_path, F_OK) == 0) {
if (connect (fd, (struct sockaddr *) &saddr, sizeof (saddr)) != -1) {
/* active socket already exists! */
close (fd);
return NULL;
}
/* remove stale socket */
unlink (saddr.sun_path);
}
if (bind (fd, (struct sockaddr *) &saddr, sizeof (saddr)) == -1) {
close (fd);
return NULL;
}
listen (fd, 5);
flags = fcntl (fd, F_GETFL, 0);
if (flags == -1) {
close (fd);
return NULL;
}
flags |= O_NONBLOCK;
flags = fcntl (fd, F_SETFL, flags);
if (flags == -1) {
close (fd);
return NULL;
}
ipct = x_new0 (xmms_ipc_transport_t, 1);
ipct->fd = fd;
ipct->path = strdup (url->path);
ipct->read_func = xmms_ipc_usocket_read;
ipct->write_func = xmms_ipc_usocket_write;
ipct->accept_func = xmms_ipc_usocket_accept;
ipct->destroy_func = xmms_ipc_usocket_destroy;
return ipct;
}
x_queue_t *
x_queue_new (void)
{
x_queue_t *queue;
queue = x_new0 (x_queue_t, 1);
return queue;
}
xmmsc_ipc_t *
xmmsc_ipc_init (void)
{
xmmsc_ipc_t *ipc;
ipc = x_new0 (xmmsc_ipc_t, 1);
ipc->disconnect = false;
ipc->results_list = NULL;
ipc->out_msg = x_queue_new ();
return ipc;
}
xmms_ipc_msg_t *
xmms_ipc_msg_alloc (void)
{
xmms_ipc_msg_t *msg;
static unsigned char empty[16] = {0,};
msg = x_new0 (xmms_ipc_msg_t, 1);
msg->bb = xmmsv_new_bitbuffer ();
xmmsv_bitbuffer_put_data (msg->bb, empty, 16);
return msg;
}
xmms_ipc_transport_t *
xmms_ipc_usocket_client_init (const xmms_url_t *url)
{
int fd;
int flags;
xmms_ipc_transport_t *ipct;
struct sockaddr_un saddr;
fd = socket (AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) {
return NULL;
}
saddr.sun_family = AF_UNIX;
snprintf (saddr.sun_path, sizeof(saddr.sun_path), "/%s", url->path);
if (connect (fd, (struct sockaddr *) &saddr, sizeof (saddr)) == -1) {
close (fd);
return NULL;
}
flags = fcntl (fd, F_GETFL, 0);
if (flags == -1) {
close (fd);
return NULL;
}
flags |= O_NONBLOCK;
flags = fcntl (fd, F_SETFL, flags);
if (flags == -1) {
close (fd);
return NULL;
}
ipct = x_new0 (xmms_ipc_transport_t, 1);
ipct->fd = fd;
ipct->path = strdup (url->path);
ipct->read_func = xmms_ipc_usocket_read;
ipct->write_func = xmms_ipc_usocket_write;
ipct->destroy_func = xmms_ipc_usocket_destroy;
return ipct;
}
static xmms_ipc_transport_t *
xmms_ipc_usocket_accept (xmms_ipc_transport_t *transport)
{
int fd;
struct sockaddr_un sin;
socklen_t sin_len;
x_return_val_if_fail (transport, NULL);
sin_len = sizeof (sin);
fd = accept (transport->fd, (struct sockaddr *)&sin, &sin_len);
if (fd >= 0) {
int flags;
xmms_ipc_transport_t *ret;
flags = fcntl (fd, F_GETFL, 0);
if (flags == -1) {
close (fd);
return NULL;
}
flags |= O_NONBLOCK;
flags = fcntl (fd, F_SETFL, flags);
if (flags == -1) {
close (fd);
return NULL;
}
ret = x_new0 (xmms_ipc_transport_t, 1);
ret->fd = fd;
ret->read_func = xmms_ipc_usocket_read;
ret->write_func = xmms_ipc_usocket_write;
ret->destroy_func = xmms_ipc_usocket_destroy;
return ret;
}
return NULL;
}
static xmms_ipc_transport_t *
xmms_ipc_tcp_accept (xmms_ipc_transport_t *transport)
{
xmms_socket_t fd;
struct sockaddr sockaddr;
socklen_t socklen;
x_return_val_if_fail (transport, NULL);
socklen = sizeof (sockaddr);
fd = accept (transport->fd, &sockaddr, &socklen);
if (xmms_socket_valid (fd)) {
int _reuseaddr = 1;
int _nodelay = 1;
const char* reuseaddr = (const char*)&_reuseaddr;
const char* nodelay = (const char*)&_nodelay;
xmms_ipc_transport_t *ret;
if (!xmms_socket_set_nonblock (fd)) {
close (fd);
return NULL;
}
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, reuseaddr, sizeof (_reuseaddr));
setsockopt (fd, IPPROTO_TCP, TCP_NODELAY, nodelay, sizeof (_nodelay));
ret = x_new0 (xmms_ipc_transport_t, 1);
ret->fd = fd;
ret->read_func = xmms_ipc_tcp_read;
ret->write_func = xmms_ipc_tcp_write;
ret->destroy_func = xmms_ipc_tcp_destroy;
return ret;
}
return NULL;
}
xmms_ipc_transport_t *
xmms_ipc_tcp_client_init (const xmms_url_t *url, int ipv6)
{
xmms_socket_t fd = -1;
xmms_ipc_transport_t *ipct;
struct addrinfo hints;
struct addrinfo *addrinfo;
struct addrinfo *addrinfos;
int gai_errno;
if (!xmms_sockets_initialize ()) {
return NULL;
}
memset (&hints, 0, sizeof (hints));
hints.ai_flags = 0;
hints.ai_family = url->host[0] ? (ipv6 ? PF_INET6 : PF_INET) : PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = 0;
if ((gai_errno = xmms_getaddrinfo (url->host[0] ? url->host : NULL, url->port[0] ? url->port : XMMS_STRINGIFY (XMMS_DEFAULT_TCP_PORT), &hints, &addrinfos))) {
return NULL;
}
for (addrinfo = addrinfos; addrinfo; addrinfo = addrinfo->ai_next) {
int _reuseaddr = 1;
const char* reuseaddr = (const char*)&_reuseaddr;
fd = socket (addrinfo->ai_family, addrinfo->ai_socktype, addrinfo->ai_protocol);
if (!xmms_socket_valid (fd)) {
return NULL;
}
setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, reuseaddr, sizeof (_reuseaddr));
if (connect (fd, addrinfo->ai_addr, addrinfo->ai_addrlen) == 0) {
break;
}
close (fd);
}
xmms_freeaddrinfo (addrinfos);
if (!addrinfo) {
return NULL;
}
assert (fd != -1);
if (!xmms_socket_set_nonblock (fd)) {
close (fd);
return NULL;
}
ipct = x_new0 (xmms_ipc_transport_t, 1);
ipct->fd = fd;
ipct->path = strdup (url->host);
ipct->read_func = xmms_ipc_tcp_read;
ipct->write_func = xmms_ipc_tcp_write;
ipct->destroy_func = xmms_ipc_tcp_destroy;
return ipct;
}
