qmremotecontrol.cpp

可以播放MP3,wma等文件格式的播放器

			info[2] = numchannels;
			ctrl_write_packet(pkt->fd, info, 3 * sizeof (gint));
			ctrl_ack_packet(pkt);
			break;
		case CMD_GET_EQ_DATA:
		case CMD_SET_EQ_DATA:
			/* obsolete */
			ctrl_ack_packet(pkt);
			break;
		case CMD_PING:
			ctrl_ack_packet(pkt);
			break;
		case CMD_PLAYLIST_ADD:
		    if (pkt->data)
 			{
 				guint32 *dataptr = reinterpret_cast<guint32*>(pkt->data);
 				while ((len = *dataptr) > 0)
 				{
 					gchar *filename;
						
 					dataptr++;
 					filename = reinterpret_cast<gchar*>(malloc(len));
 					memcpy(filename, dataptr, len);
 					if (QmMainWindow::mainwin->playListAdd(filename, true))
						if (!QmMainWindow::mainwin->isPlaying())
							QmMainWindow::mainwin->play();
 					free(filename);
 					dataptr += (len + 3) / 4;
 				}
 			}
			ctrl_ack_packet(pkt);
			break;
		case CMD_PLAYLIST_ADD_URL_STRING:
		    QmMainWindow::mainwin->playListAppendFile(reinterpret_cast<char*>(pkt->data));
			ctrl_ack_packet(pkt);
			break;
		case CMD_PLAYLIST_DELETE:
 			QmMainWindow::mainwin->playListDeletePosition(*((guint32 *)pkt->data));
			ctrl_ack_packet(pkt);
			break;
		case CMD_PLAYLIST_CLEAR:
			QmMainWindow::mainwin->clearPlayList();
			ctrl_ack_packet(pkt);
			break;
		case CMD_IS_MAIN_WIN:
			ctrl_write_gboolean(pkt->fd, QmMainWindow::mainwin->isVisible() ? 1 : 0);
			ctrl_ack_packet(pkt);
			break;
		case CMD_IS_PL_WIN:
			ctrl_write_gboolean(pkt->fd, 1);
			ctrl_ack_packet(pkt);
			break;
		case CMD_IS_EQ_WIN:
			ctrl_write_gboolean(pkt->fd, 0);
			ctrl_ack_packet(pkt);
			break;
		case CMD_IS_REPEAT:
			ctrl_write_gboolean(pkt->fd, 1);
			ctrl_ack_packet(pkt);
			break;
		case CMD_IS_SHUFFLE:
			ctrl_write_gboolean(pkt->fd, (QmMainWindow::mainwin->randomMode() ? 1 : 0));
			ctrl_ack_packet(pkt);
			break;
		case CMD_GET_EQ:
// 			fval[0] = equalizerwin_get_preamp();
// 			for(i = 0; i < 10; i++)
// 				fval[i + 1] = equalizerwin_get_band(i);
// 			ctrl_write_packet(pkt->fd, fval, 11 * sizeof(gfloat));
			ctrl_ack_packet(pkt);
			break;
		case CMD_GET_EQ_PREAMP:
// 			ctrl_write_gfloat(pkt->fd, equalizerwin_get_preamp());
			ctrl_ack_packet(pkt);
			break;
		case CMD_GET_EQ_BAND:
// 			i = *((guint32 *) pkt->data);
// 			ctrl_write_gfloat(pkt->fd, equalizerwin_get_band(i));
			ctrl_ack_packet(pkt);
			break;

		case CMD_PLAY:
		    ctrl_ack_packet(pkt);
			QmMainWindow::mainwin->play();
			break;
		case CMD_PAUSE:
			QmMainWindow::mainwin->pause(); ctrl_ack_packet(pkt);
			break;
		case CMD_STOP:
			QmMainWindow::mainwin->stop(); ctrl_ack_packet(pkt);
			break;
		case CMD_SET_PLAYLIST_POS:
            QmMainWindow::mainwin->playListPosition(*((guint32 *) data));
			ctrl_ack_packet(pkt);
			break;
		case CMD_JUMP_TO_TIME:
 			num = *((guint32 *) data);
			QmMainWindow::mainwin->jumpToSeconds(num / 1000);
			ctrl_ack_packet(pkt);
			break;
		case CMD_SET_VOLUME:
			v[0] = ((guint32 *) data)[0];
			v[1] = ((guint32 *) data)[1];
			if (v[0] > 100) v[0] = 100;
			if (v[1] > 100) v[1] = 100;

			QmMainWindow::mainwin->setVolume(v[0]);
			ctrl_ack_packet(pkt);
			break;
		case CMD_SET_SKIN:
			// right.
 		    ctrl_ack_packet(pkt);
			break;
		case CMD_PL_WIN_TOGGLE:
			 ctrl_ack_packet(pkt);
			break;
		case CMD_EQ_WIN_TOGGLE:
			ctrl_ack_packet(pkt);
			break;
		case CMD_SHOW_PREFS_BOX:
			QmMainWindow::mainwin->configDialog();
			ctrl_ack_packet(pkt);
			break;
		case CMD_TOGGLE_AOT:
//			tbool = *((gboolean *) data);
//			mainwin_set_always_on_top(tbool);
			ctrl_ack_packet(pkt);
			break;
		case CMD_SHOW_ABOUT_BOX:
			QmMainWindow::mainwin->showAbout();
			 ctrl_ack_packet(pkt);
			break;
		case CMD_EJECT:
			QmMainWindow::mainwin->addFilesDialog();
			 ctrl_ack_packet(pkt);
			break;
		case CMD_PLAYLIST_PREV:
			QmMainWindow::mainwin->prev();
			 ctrl_ack_packet(pkt);
			break;
		case CMD_PLAYLIST_NEXT:
			QmMainWindow::mainwin->next();
			 ctrl_ack_packet(pkt);
			break;
		case CMD_TOGGLE_REPEAT:
			QmMainWindow::mainwin->cycleLoopMode();
			if (QmMainWindow::mainwin->loopOneMode())
				QmMainWindow::mainwin->cycleLoopMode();
			ctrl_ack_packet(pkt);
			break;
		case CMD_TOGGLE_SHUFFLE:
			QmMainWindow::mainwin->toggleRandomMode();
			ctrl_ack_packet(pkt);
			break;
		case CMD_MAIN_WIN_TOGGLE:
			QmMainWindow::mainwin->toggleCompactWindow();
			ctrl_ack_packet(pkt);
			break;
		case CMD_SET_EQ:
// 			if(pkt->hdr.data_length >= 11 * sizeof(gfloat)) {
// 				fval = (gfloat *) data;
// 				equalizerwin_set_preamp(fval[0]);
// 				for(i = 0; i < 10; i++)
// 					equalizerwin_set_band(i, fval[i + 1]);
// 			}
			 ctrl_ack_packet(pkt);
			break;
		case CMD_SET_EQ_PREAMP:
// 			f = *((gfloat *) data);
// 			equalizerwin_set_preamp(f);
			ctrl_ack_packet(pkt);			
			break;
		case CMD_SET_EQ_BAND:
// 			if(pkt->hdr.data_length >= sizeof(gint) + sizeof(gfloat))
// 			{
// 				i = *((gint *) data);
// 				f = *((gfloat *) ((gchar *)data + sizeof(gint)));
// 				equalizerwin_set_band(i, f);
// 			}
			ctrl_ack_packet(pkt);						
			break;
		case CMD_QUIT:
			qApp->quit();
			ctrl_ack_packet(pkt); 
			break;

		default:
// 			pthread_mutex_lock(&packet_list_mutex);
//			packet_list.push_back(pkt);
// 			packet_list = g_list_append(packet_list, pkt);
			std::cerr << "QmRemoteControl::ctrlsocket_func: unknown command: " << pkt->hdr.command << "\n";
 			ctrl_write_packet(pkt->fd, NULL, 0);
 			close(pkt->fd);
// 			pthread_mutex_unlock(&packet_list_mutex);
			break;
	}
}

// g_get_tmp_dir from glib
char *
QmRemoteControl::g_get_tmp_dir()
{
	static char *g_tmp_dir=0;
	if (!g_tmp_dir)
    {
		g_tmp_dir = getenv ("TMPDIR");
		if (!g_tmp_dir)
			g_tmp_dir = getenv ("TMP");
		if (!g_tmp_dir)
			g_tmp_dir = getenv ("TEMP");

		if (g_tmp_dir)
			g_tmp_dir = strdup(g_tmp_dir);
		else 
		{
#ifndef NATIVE_WIN32
			g_tmp_dir = "/tmp";
#else /* NATIVE_WIN32 */
			g_tmp_dir = "C:\\";
#endif /* NATIVE_WIN32 */
		}
	}
	return g_tmp_dir;
}

gboolean
QmRemoteControl::remote_cmd(gint session, guint32 cmd)
{
	gint fd;
	if ((fd = apollo_connect_to_session(session)) == -1)
		return FALSE;
	remote_send_packet(fd, cmd, NULL, 0);
	remote_read_ack(fd);
	close(fd);
	
	return TRUE;
}

gint
QmRemoteControl::apollo_connect_to_session(gint session)
{
	gint fd;
	uid_t stored_uid, euid;
	struct sockaddr_un saddr;
	
	if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) != -1)
	{
		saddr.sun_family = AF_UNIX;
		stored_uid = getuid();
		euid = geteuid();
		setuid(euid);
		struct passwd *pwd = getpwuid(getuid());
		const char *user_name = pwd ? pwd->pw_name : "wtf?"; // failure should be logged
		sprintf(saddr.sun_path, "%s/%s_%s.%d", g_get_tmp_dir(), app_name_for_socket, user_name, session);
		setreuid(stored_uid, euid);
		if (::connect(fd, (struct sockaddr *) &saddr, sizeof (saddr)) != -1)
			return fd;
	}
	close(fd);
	return -1;
}

void
QmRemoteControl::remote_read_ack(gint fd)
{
	gpointer data;
	ServerPktHeader pkt_hdr;

	data = remote_read_packet(fd, &pkt_hdr);
	if (data)
		free(data);

}

void
QmRemoteControl::remote_send_packet(gint fd, guint32 command, gpointer data, guint32 data_length)
{
	ClientPktHeader pkt_hdr;

	pkt_hdr.version = XMMS_PROTOCOL_VERSION;
	pkt_hdr.command = command;
	pkt_hdr.data_length = data_length;
	write(fd, &pkt_hdr, sizeof (ClientPktHeader));
	if (data_length && data)
		write(fd, data, data_length);
}

gpointer
QmRemoteControl::remote_read_packet(gint fd, ServerPktHeader * pkt_hdr)
{
	gpointer data = NULL;

	if (read(fd, pkt_hdr, sizeof (ServerPktHeader)) == sizeof (ServerPktHeader))
	{
		if (pkt_hdr->data_length)
		{
			data = malloc(pkt_hdr->data_length);
			read(fd, data, pkt_hdr->data_length);
		}
	}
	return data;
}

/*! Used for debugging, to see what a client is requesting */
void
QmRemoteControl::print_cmd(guint16 cmd) 
{
	switch (cmd) {
		case CMD_GET_VERSION: std::cerr << "CMD_GET_VERSION\n"; break;
		case CMD_PLAYLIST_ADD: std::cerr << "CMD_PLAYLIST_ADD\n"; break;
		case CMD_PLAY: std::cerr << "CMD_PLAY\n"; break;
		case CMD_PAUSE: std::cerr << "CMD_PAUSE\n"; break;
		case CMD_STOP: std::cerr << "CMD_STOP\n"; break;
		case CMD_IS_PLAYING: std::cerr << "CMD_IS_PLAYING\n"; break;
		case CMD_IS_PAUSED: std::cerr << "CMD_IS_PAUSED\n"; break;
		case CMD_GET_PLAYLIST_POS: std::cerr << "CMD_GET_PLAYLIST_POS\n"; break;
		case CMD_SET_PLAYLIST_POS: std::cerr << "CMD_SET_PLAYLIST_POS\n"; break;
		case CMD_GET_PLAYLIST_LENGTH: std::cerr << "CMD_GET_PLAYLIST_LENGTH\n"; break;
		case CMD_PLAYLIST_CLEAR: std::cerr << "CMD_PLAYLIST_CLEAR\n"; break;
		case CMD_GET_OUTPUT_TIME: std::cerr << "CMD_GET_OUTPUT_TIME\n"; break;
		case CMD_JUMP_TO_TIME: std::cerr << "CMD_JUMP_TO_TIME\n"; break;
		case CMD_GET_VOLUME: std::cerr << "CMD_GET_VOLUME\n"; break;
		case CMD_SET_VOLUME: std::cerr << "CMD_SET_VOLUME\n"; break;
		case CMD_GET_SKIN: std::cerr << "CMD_GET_SKIN\n"; break;
		case CMD_SET_SKIN: std::cerr << "CMD_SET_SKIN\n"; break;
		case CMD_GET_PLAYLIST_FILE: std::cerr << "CMD_GET_PLAYLIST_FILE\n"; break;
		case CMD_GET_PLAYLIST_TITLE: std::cerr << "CMD_GET_PLAYLIST_TITLE\n"; break;
		case CMD_GET_PLAYLIST_TIME: std::cerr << "CMD_GET_PLAYLIST_TIME\n"; break;
		case CMD_GET_INFO: std::cerr << "CMD_GET_INFO\n"; break;
		case CMD_GET_EQ_DATA: std::cerr << "CMD_GET_EQ_DATA\n"; break;
		case CMD_SET_EQ_DATA: std::cerr << "CMD_SET_EQ_DATA\n"; break;
		case CMD_PL_WIN_TOGGLE: std::cerr << "CMD_PL_WIN_TOGGLE\n"; break;
		case CMD_EQ_WIN_TOGGLE: std::cerr << "CMD_EQ_WIN_TOGGLE\n"; break;
		case CMD_SHOW_PREFS_BOX: std::cerr << "CMD_SHOW_PREFS_BOX\n"; break;
		case CMD_TOGGLE_AOT: std::cerr << "CMD_TOGGLE_AOT\n"; break;
		case CMD_SHOW_ABOUT_BOX: std::cerr << "CMD_SHOW_ABOUT_BOX\n"; break;
		case CMD_EJECT: std::cerr << "CMD_EJECT\n"; break;
		case CMD_PLAYLIST_PREV: std::cerr << "CMD_PLAYLIST_PREV\n"; break;
		case CMD_PLAYLIST_NEXT: std::cerr << "CMD_PLAYLIST_NEXT\n"; break;
		case CMD_PING: std::cerr << "CMD_PING\n"; break;
		case CMD_GET_BALANCE: std::cerr << "CMD_GET_BALANCE\n"; break;
		case CMD_TOGGLE_REPEAT: std::cerr << "CMD_TOGGLE_REPEAT\n"; break;
		case CMD_TOGGLE_SHUFFLE: std::cerr << "CMD_TOGGLE_SHUFFLE\n"; break;
		case CMD_MAIN_WIN_TOGGLE: std::cerr << "CMD_MAIN_WIN_TOGGLE\n"; break;
		case CMD_PLAYLIST_ADD_URL_STRING: std::cerr << "CMD_PLAYLIST_ADD_URL_STRING\n"; break;
		case CMD_IS_EQ_WIN: std::cerr << "CMD_IS_EQ_WIN\n"; break;
		case CMD_IS_PL_WIN: std::cerr << "CMD_IS_PL_WIN\n"; break;
		case CMD_IS_MAIN_WIN: std::cerr << "CMD_IS_MAIN_WIN\n"; break;
		case CMD_PLAYLIST_DELETE: std::cerr << "CMD_PLAYLIST_DELETE\n"; break;
		case CMD_IS_REPEAT: std::cerr << "CMD_IS_REPEAT\n"; break;
		case CMD_IS_SHUFFLE: std::cerr << "CMD_IS_SHUFFLE\n"; break;
		case CMD_GET_EQ: std::cerr << "CMD_GET_EQ\n"; break;
		case CMD_GET_EQ_PREAMP: std::cerr << "CMD_GET_EQ_PREAMP\n"; break;
		case CMD_GET_EQ_BAND: std::cerr << "CMD_GET_EQ_BAND\n"; break;
		case CMD_SET_EQ: std::cerr << "CMD_SET_EQ\n"; break;
		case CMD_SET_EQ_PREAMP: std::cerr << "CMD_SET_EQ_PREAMP\n"; break;
		case CMD_SET_EQ_BAND: std::cerr << "CMD_SET_EQ_BAND\n"; break;
		case CMD_QUIT: std::cerr << "CMD_QUIT\n"; break;
		default: std::cerr << "unknow command\n"; break;
	}
}