/* * Sends a password to the mpd server * FIXME: should retrieve updated privileges list? */ bool Control::sendpassword(string pw) { EXIT_IDLE; return mpd_run_password(conn->h(), pw.c_str()); }
void Connection::SendPassword() { assert(m_connection); noidle(); assert(!m_command_list_active); mpd_run_password(m_connection.get(), m_password.c_str()); checkErrors(); }
static int mpd_update() { struct timeval now; /* reread every 1000 msec only */ gettimeofday(&now, NULL); int timedelta = (now.tv_sec - timestamp.tv_sec) * 1000 + (now.tv_usec - timestamp.tv_usec) / 1000; if (timedelta > 0 && timedelta < waittime) { /* debug("[MPD] waittime not reached...\n"); */ return 1; } /* check if configured */ if (configure_mpd() < 0) { return -1; } /* check if connected */ if (conn == NULL || mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { if (conn) { if (errorcnt < ERROR_DISPLAY) mpd_printerror("reconnect"); } else debug("[MPD] initialize connect to [%s]:[%i]", host, iport); } if (!conn) { conn = mpd_connection_new(host, iport, TIMEOUT_IN_S * 1000); if (conn == NULL || mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { if (conn) { if (errorcnt < ERROR_DISPLAY) mpd_printerror("connect"); } if (errorcnt == ERROR_DISPLAY) error("[MPD] stop logging, until connection is fixed!"); errorcnt++; gettimeofday(×tamp, NULL); return -1; } if (*pw && !mpd_run_password(conn, pw)) { errorcnt++; mpd_printerror("run_password"); return -1; } errorcnt = 0; debug("[MPD] connection fixed..."); } mpd_query_status(conn); mpd_query_stats(conn); gettimeofday(×tamp, NULL); return 1; }
void mpd_poll(struct mg_server *s) { switch (mpd.conn_state) { case MPD_DISCONNECTED: /* Try to connect */ fprintf(stdout, "MPD Connecting to %s:%d\n", mpd.host, mpd.port); mpd.conn = mpd_connection_new(mpd.host, mpd.port, 3000); if (mpd.conn == NULL) { fprintf(stderr, "Out of memory."); mpd.conn_state = MPD_FAILURE; return; } if (mpd_connection_get_error(mpd.conn) != MPD_ERROR_SUCCESS) { fprintf(stderr, "MPD connection: %s\n", mpd_connection_get_error_message(mpd.conn)); mg_iterate_over_connections(s, mpd_notify_callback, (void *)mpd_connection_get_error_message(mpd.conn)); mpd.conn_state = MPD_FAILURE; return; } if(mpd.password && !mpd_run_password(mpd.conn, mpd.password)) { fprintf(stderr, "MPD connection: %s\n", mpd_connection_get_error_message(mpd.conn)); mg_iterate_over_connections(s, mpd_notify_callback, (void *)mpd_connection_get_error_message(mpd.conn)); mpd.conn_state = MPD_FAILURE; return; } fprintf(stderr, "MPD connected.\n"); mpd_connection_set_timeout(mpd.conn, 10000); mpd.conn_state = MPD_CONNECTED; break; case MPD_FAILURE: fprintf(stderr, "MPD connection failed.\n"); case MPD_DISCONNECT: case MPD_RECONNECT: if(mpd.conn != NULL) mpd_connection_free(mpd.conn); mpd.conn = NULL; mpd.conn_state = MPD_DISCONNECTED; break; case MPD_CONNECTED: mpd.buf_size = mpd_put_state(mpd.buf, &mpd.song_id, &mpd.queue_version); mg_iterate_over_connections(s, mpd_notify_callback, NULL); break; } }
/* * pgmpc_init * * Initialize connection to mpd server. */ static void pgmpc_init(void) { Assert(mpd_conn == NULL); /* Establish connection to mpd server */ mpd_conn = mpd_connection_new(mpd_host, mpd_port, mpd_timeout * 1000); if (mpd_connection_get_error(mpd_conn) != MPD_ERROR_SUCCESS) pgmpc_print_error(); /* Send password if any */ if (mpd_password[0]) { if (!mpd_run_password(mpd_conn, mpd_password)) pgmpc_print_error(); } }
bool CMPD::Connect() { if(_conn) mpd_connection_free(_conn); _conn = mpd_connection_new(Config->getMHost().c_str(), Config->getMPort(), 0); _connected = _conn && mpd_connection_get_error(_conn) == MPD_ERROR_SUCCESS; if(_connected && Config->getMPassword().size() > 0) { _connected &= mpd_run_password(_conn, Config->getMPassword().c_str()); } if(_connected) mpd_run_subscribe(_conn, "mpdas"); return _connected; }
bool CMPD::Connect() { if(_conn) mpd_connection_free(_conn); _conn = mpd_connection_new(_cfg->Get("host").c_str(), _cfg->GetInt("port"), 0); _connected = _conn && mpd_connection_get_error(_conn) == MPD_ERROR_SUCCESS; if(_connected && _cfg->Get("mpdpassword").size() > 0) { _connected &= mpd_run_password(_conn, _cfg->Get("mpdpassword").c_str()); } else if(!_connected) { eprintf("MPD connection error: %s", mpd_connection_get_error_message(_conn)); } if(_connected) mpd_run_subscribe(_conn, "mpdas"); return _connected; }
int main(int argc, char *argv[]) { char *password = NULL; struct mpd_connection *conn = mpd_connection_new(mpd_check_host(NULL, &password), 0, 0); if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { fprintf(stderr,"%s: %s\n", argv[0], mpd_connection_get_error_message(conn)); return 1; } if (password != NULL) { if (mpd_run_password(conn, password) == false) { fprintf(stderr, "%s: mpd_run_password %s\n", argv[0], mpd_connection_get_error_message(conn)); free(password); return 2; } } if (notify_init("MPD_Notification") == 0) { fprintf(stderr, "%s: Cannot initialize libnotify.\n", argv[0]); return 3; } infinite_loop(conn); mpd_connection_free(conn); free(password); notify_uninit(); return 0; }
int main(int argc, char *argv[]) { int opts; const char *short_opts = "t:r:b:a:p:s:h"; struct option long_opts[] = { { "title", required_argument, 0, 't' }, { "artist", required_argument, 0, 'r' }, { "album", required_argument, 0, 'b' }, { "addr", required_argument, 0, 'a' }, { "port", required_argument, 0, 'p' }, { "secret", required_argument, 0, 's' }, { "help", no_argument, 0, 'h' }, { 0, 0, 0, 0 } }; unsigned int id = 0; struct mpd_song *song = NULL; struct mpd_connection *mpd = NULL; char *mpd_addr = getenv("MPD_HOST"); int mpd_port = getenv("MPD_PORT") ? atoi(getenv("MPD_PORT")) : 0; char *mpd_pass = NULL; char *title = NULL; char *artist = NULL; char *album = NULL; if (argc == 1) { help(); return -1; } while ((opts = getopt_long(argc, argv, short_opts, long_opts, 0)) != -1) { switch (opts) { case 't': { title = optarg; break; } case 'r': { artist = optarg; break; } case 'b': { album = optarg; break; } case 'a': { mpd_addr = optarg; break; } case 'p': { mpd_port = atoi(optarg); break; } case 's': { mpd_pass = optarg; break; } default : case 'h': { help(); return -1; } } } mpd = mpd_connection_new(mpd_addr, mpd_port, 30000); CHECK_MPD_CONN(mpd); if (mpd_pass != NULL) { mpd_run_password(mpd, mpd_pass); CHECK_MPD_CONN(mpd); } mpd_search_queue_songs(mpd, false); if (title) { mpd_search_add_tag_constraint( mpd, MPD_OPERATOR_DEFAULT, MPD_TAG_TITLE, title ); } if (artist) { mpd_search_add_tag_constraint( mpd, MPD_OPERATOR_DEFAULT, MPD_TAG_ARTIST, artist ); } if (album) { mpd_search_add_tag_constraint( mpd, MPD_OPERATOR_DEFAULT, MPD_TAG_ALBUM, album ); } mpd_search_commit(mpd); song = mpd_recv_song(mpd); mpd_response_finish(mpd); if (song) { id = mpd_song_get_id(song); mpd_song_free(song); mpd_run_play_id(mpd, id); CHECK_MPD_CONN(mpd); } mpd_connection_free(mpd); return 0; }
/* Establish a connection with the MPD server * If the connection failed, the "conn" is set to NULL */ void Player::connectToMpd() { QSettings settings; unsigned int retryPeriod; QString host; unsigned int port; unsigned int timeout; QString password; EMS_LOAD_SETTINGS(retryPeriod, "player/retry_period", EMS_MPD_CONNECTION_RETRY_PERIOD, UInt); EMS_LOAD_SETTINGS(host, "player/host", EMS_MPD_IP, String); EMS_LOAD_SETTINGS(timeout, "player/timeout", EMS_MPD_TIMEOUT, UInt); EMS_LOAD_SETTINGS(port, "player/port", EMS_MPD_PORT, UInt); EMS_LOAD_SETTINGS(password, "player/password", EMS_MPD_PASSWORD, String); if (conn != NULL) { disconnectToMpd(); } /* Try to connect until it success */ while (!conn && !isInterruptionRequested()) { qDebug() << "Connecting to " << QString("%1:%2... (timeout %3ms)").arg(host).arg(port).arg(timeout); conn = mpd_connection_new(host.toStdString().c_str(), port, timeout); if (conn == NULL) { qCritical() << "MPD Connection failed."; } else if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { QString errorMessage = QString::fromUtf8(mpd_connection_get_error_message(conn)); qCritical() << "MPD Connection failed : " << errorMessage; mpd_connection_free(conn); conn = NULL; } else if (!password.isEmpty()) { qDebug() << "Setting password..."; if (!mpd_run_password(conn, password.toStdString().c_str())) { qCritical() << "Setting MPD password failed."; mpd_connection_free(conn); conn = NULL; } } if (!conn) { qCritical() << "Retrying within " << QString("%1 ms").arg(retryPeriod); for (unsigned int i=0; i<retryPeriod; i++) { if (!isInterruptionRequested()) usleep(1000); else break; } } } qDebug() << "Connected to " << host; }
struct mpd_connection * mpd_connection_new(const char *host, unsigned port, unsigned timeout_ms) { struct mpd_connection *connection = malloc(sizeof(*connection)); bool success; int fd; const char *line; char *password = NULL; if (connection == NULL) return NULL; mpd_error_init(&connection->error); connection->async = NULL; connection->parser = NULL; connection->receiving = false; connection->sending_command_list = false; connection->pair_state = PAIR_STATE_NONE; connection->request = NULL; if (!mpd_socket_global_init(&connection->error)) return connection; if (timeout_ms == 0) /* 30s is the default */ timeout_ms = 30000; mpd_connection_set_timeout(connection, timeout_ms); host = mpd_check_host(host, &password); port = mpd_check_port(port); fd = mpd_connect(host, port, &connection->timeout, &connection->error); if (fd < 0) { free(password); return connection; } connection->async = mpd_async_new(fd); if (connection->async == NULL) { free(password); mpd_socket_close(fd); mpd_error_code(&connection->error, MPD_ERROR_OOM); return connection; } connection->parser = mpd_parser_new(); if (connection->parser == NULL) { free(password); mpd_error_code(&connection->error, MPD_ERROR_OOM); return connection; } line = mpd_sync_recv_line(connection->async, &connection->timeout); if (line == NULL) { free(password); mpd_connection_sync_error(connection); return connection; } success = mpd_parse_welcome(connection, line); if (password != NULL) { if (success) mpd_run_password(connection, password); free(password); } return connection; }
void print_mpd(yajl_gen json_gen, char *buffer, const char *host, int port, const char *password, const char *format) { const char *walk; char *outwalk = buffer; static char titlebuf[40]; static char artistbuf[40]; static char albumbuf[40]; static char trackbuf[10]; static char datebuf[10]; static struct mpd_connection *conn; struct mpd_status *status = NULL; enum mpd_state state; struct mpd_song *song; /* First run */ if (conn == NULL) { conn = mpd_connection_new(host, port, 1500); if (conn == NULL) { START_COLOR("color_bad"); outwalk += sprintf(outwalk, "%s", "ERROR"); goto print_end; } if (mpd_connection_get_error(conn) != MPD_ERROR_SUCCESS) { START_COLOR("color_bad"); outwalk += sprintf(outwalk, "%s", "CONNECT ERROR"); mpd_connection_free(conn); conn = NULL; goto print_end; } if (password != NULL && strcmp(password, "") != 0 && !mpd_run_password(conn, password)) { START_COLOR("color_bad"); outwalk += sprintf(outwalk, "%s", "PASS ERROR"); mpd_connection_free(conn); conn = NULL; goto print_end; } } if ((status = mpd_run_status(conn))) { state = mpd_status_get_state(status); } if (!status || (state != MPD_STATE_PLAY && state != MPD_STATE_PAUSE)) { START_COLOR("color_bad"); outwalk += sprintf(outwalk, "%s", "Stopped"); mpd_connection_free(conn); conn = NULL; goto print_end; } mpd_status_free(status); if (state == MPD_STATE_PLAY) START_COLOR("color_good"); else if (state == MPD_STATE_PAUSE) START_COLOR("color_degraded"); song = mpd_run_current_song(conn); COPY_CROP(titlebuf, mpd_song_get_tag(song, MPD_TAG_TITLE, 0)); COPY_CROP(artistbuf, mpd_song_get_tag(song, MPD_TAG_ARTIST, 0)); COPY_CROP(albumbuf, mpd_song_get_tag(song, MPD_TAG_ALBUM, 0)); COPY_CROP(trackbuf, mpd_song_get_tag(song, MPD_TAG_TRACK, 0)); COPY_CROP(datebuf, mpd_song_get_tag(song, MPD_TAG_DATE, 0)); mpd_song_free(song); for (walk = format; *walk != '\0'; walk++) { if (*walk != '%') { *(outwalk++) = *walk; continue; } if (BEGINS_WITH(walk+1, "title")) { if (*titlebuf) outwalk += sprintf(outwalk, "%s", titlebuf); walk += strlen("title"); } else if (BEGINS_WITH(walk+1, "artist")) { if (*artistbuf) outwalk += sprintf(outwalk, "%s", artistbuf); walk += strlen("artist"); } else if (BEGINS_WITH(walk+1, "album")) { if (*albumbuf) outwalk += sprintf(outwalk, "%s", albumbuf); walk += strlen("album"); } else if (BEGINS_WITH(walk+1, "track")) { if (*trackbuf) outwalk += sprintf(outwalk, "%s", trackbuf); walk += strlen("track"); } else if (BEGINS_WITH(walk+1, "date")) { if (*datebuf) outwalk += sprintf(outwalk, "%s", datebuf); walk += strlen("date"); } } print_end: END_COLOR; OUTPUT_FULL_TEXT(buffer); return; }