static menuSound_t PingSelected(void)
{
serverslot_t *slot;
netadr_t address;
char *hostname;
if (!m_servers.list.numItems)
return QMS_BEEP;
if (m_servers.list.curvalue < 0)
return QMS_BEEP;
slot = m_servers.list.items[m_servers.list.curvalue];
address = slot->address;
hostname = slot->hostname;
FreeSlot(slot);
slot = UI_FormatColumns(SLOT_EXTRASIZE, hostname,
"???", "???", "?/?", "???", NULL);
slot->status = SLOT_PENDING;
slot->address = address;
slot->hostname = hostname;
slot->color = U32_WHITE;
slot->numRules = 0;
slot->numPlayers = 0;
slot->timestamp = com_eventTime;
m_servers.list.items[m_servers.list.curvalue] = slot;
UpdateStatus();
UpdateSelection();
CL_SendStatusRequest(&slot->address);
return QMS_SILENT;
}
//_________________________________________________________
void RemoveSlotList (SlotPtr slot, Boolean input)
{
OSStatus err;
SlotPtr next;
while (slot) {
next = slot->next;
if (input) err = MIDIPortDisconnectSource(gInPort, slot->src); // disconnect source
MidiRemoveSlot(slot->refNum);
FreeSlot (slot);
slot = next;
}
}
//_________________________________________________________
static SlotPtr CreateSlot(short refNum, char *name, SlotDirection dir, MIDIEndpointRef src)
{
SlotPtr slot = NewSlot ();
if (!slot) return 0;
slot->refNum = MidiAddSlot (refNum, name, dir);
if (Slot(slot->refNum) < 0) {
FreeSlot (slot);
return 0;
}
slot->src = src;
MidiStreamInit (&slot->state.outsmall, gLinMethods);
MidiStreamInit (&slot->outsysex, gLinMethods);
MidiParseInit (&slot->in, gParseTbl, gTypeTbl);
slot->next = 0;
return slot;
}
/*
=================
UI_ErrorEvent
An ICMP destination-unreachable error has been received.
=================
*/
void UI_ErrorEvent(netadr_t *from)
{
serverslot_t *slot;
netadr_t address;
char *hostname;
unsigned timestamp, ping;
int i;
// ignore unless menu is up
if (!m_servers.args)
return;
slot = FindSlot(from, &i);
if (!slot)
return;
// only mark unreplied slots as invalid
if (slot->status != SLOT_PENDING)
return;
address = slot->address;
hostname = slot->hostname;
timestamp = slot->timestamp;
FreeSlot(slot);
if (timestamp > com_eventTime)
timestamp = com_eventTime;
ping = com_eventTime - timestamp;
if (ping > 999)
ping = 999;
slot = UI_FormatColumns(SLOT_EXTRASIZE, hostname,
"???", "???", "down", va("%u", ping), NULL);
slot->status = SLOT_ERROR;
slot->address = address;
slot->hostname = hostname;
slot->color = U32_WHITE;
slot->numRules = 0;
slot->numPlayers = 0;
slot->timestamp = timestamp;
m_servers.list.items[i] = slot;
}
static void ClearServers(void)
{
serverslot_t *slot;
int i;
for (i = 0; i < m_servers.list.numItems; i++) {
slot = m_servers.list.items[i];
m_servers.list.items[i] = NULL;
Z_Free(slot->hostname);
FreeSlot(slot);
}
m_servers.list.numItems = 0;
m_servers.list.curvalue = -1;
m_servers.list.prestep = 0;
m_servers.info.items = NULL;
m_servers.info.numItems = 0;
m_servers.players.items = NULL;
m_servers.players.numItems = 0;
m_servers.pingstage = 0;
}
int send_transaction_packet(int s, struct QItem TxnQItem)
{
void *data = NULL;
int length = 0;
int interaction;
int result;
interaction = TxnQItem.TxnType;
if (_send(s, &interaction, sizeof(int)) == -1)
{
LOG_ERROR_MESSAGE("cannot send interaction type");
return ERROR;
}
switch (interaction)
{
case ADMIN_CONFIRM:
result = app_admin_confirm_array.txn_result[TxnQItem.SlotID];
break;
case ADMIN_REQUEST:
result = app_admin_request_array.txn_result[TxnQItem.SlotID];
break;
case BEST_SELLERS:
result = app_best_sellers_array.txn_result[TxnQItem.SlotID];
break;
case BUY_CONFIRM:
result = app_buy_confirm_array.txn_result[TxnQItem.SlotID];
break;
case BUY_REQUEST:
result = app_buy_request_array.txn_result[TxnQItem.SlotID];
break;
case HOME:
result = app_home_array.txn_result[TxnQItem.SlotID];
break;
case NEW_PRODUCTS:
result = app_new_products_array.txn_result[TxnQItem.SlotID];
break;
case ORDER_DISPLAY:
result = app_order_display_array.txn_result[TxnQItem.SlotID];
break;
case ORDER_INQUIRY:
result = app_order_inquiry_array.txn_result[TxnQItem.SlotID];
break;
case PRODUCT_DETAIL:
result = app_product_detail_array.txn_result[TxnQItem.SlotID];
break;
case SEARCH_REQUEST:
result = app_search_request_array.txn_result[TxnQItem.SlotID];
break;
case SEARCH_RESULTS:
result = app_search_results_array.txn_result[TxnQItem.SlotID];
break;
case SHOPPING_CART:
result = app_shopping_cart_array.txn_result[TxnQItem.SlotID];
break;
}
if (_send(s, &result, sizeof(int)) == -1)
{
LOG_ERROR_MESSAGE("cannot send interaction result");
return ERROR;
}
if (result == OK)
{
switch (interaction)
{
case ADMIN_CONFIRM:
data = &(app_admin_confirm_array.data_array[TxnQItem.SlotID].admin_confirm_data);
length = sizeof(struct admin_confirm_t);
break;
case ADMIN_REQUEST:
data = &(app_admin_request_array.data_array[TxnQItem.SlotID].admin_request_data);
length = sizeof(struct admin_request_t);
break;
case BEST_SELLERS:
data = &(app_best_sellers_array.data_array[TxnQItem.SlotID].best_sellers_data);
length = sizeof(struct best_sellers_t);
break;
case BUY_CONFIRM:
data = &(app_buy_confirm_array.data_array[TxnQItem.SlotID].buy_confirm_data);
length = sizeof(struct buy_confirm_t);
break;
case BUY_REQUEST:
data = &(app_buy_request_array.data_array[TxnQItem.SlotID].buy_request_data);
length = sizeof(struct buy_request_t);
break;
case HOME:
data = &(app_home_array.data_array[TxnQItem.SlotID].home_data);
length = sizeof(struct home_t);
break;
case NEW_PRODUCTS:
data = &(app_new_products_array.data_array[TxnQItem.SlotID].new_products_data);
length = sizeof(struct new_products_t);
break;
case ORDER_DISPLAY:
data = &(app_order_display_array.data_array[TxnQItem.SlotID].order_display_data);
length = sizeof(struct order_display_t);
break;
case ORDER_INQUIRY:
data = &(app_order_inquiry_array.data_array[TxnQItem.SlotID].order_inquiry_data);
length = sizeof(struct order_inquiry_t);
break;
case PRODUCT_DETAIL:
data = &(app_product_detail_array.data_array[TxnQItem.SlotID].product_detail_data);
length = sizeof(struct product_detail_t);
break;
case SEARCH_REQUEST:
data = &(app_search_request_array.data_array[TxnQItem.SlotID].search_request_data);
length = sizeof(struct search_request_t);
break;
case SEARCH_RESULTS:
data = &(app_search_results_array.data_array[TxnQItem.SlotID].search_results_data);
length = sizeof(struct search_results_t);
break;
case SHOPPING_CART:
data = &(app_shopping_cart_array.data_array[TxnQItem.SlotID].shopping_cart_data);
length = sizeof(struct shopping_cart_t);
break;
}
if (_send(s, data, length) == -1)
{
LOG_ERROR_MESSAGE("cannot send interaction data, errno %d", errno);
return ERROR;
}
}
/* free slot */
switch (TxnQItem.TxnType)
{
case ADMIN_CONFIRM:
FreeSlot(&app_admin_confirm_array, TxnQItem.SlotID);
break;
case ADMIN_REQUEST:
FreeSlot(&app_admin_request_array, TxnQItem.SlotID);
break;
case BEST_SELLERS:
FreeSlot(&app_best_sellers_array, TxnQItem.SlotID);
break;
case BUY_REQUEST:
FreeSlot(&app_buy_request_array, TxnQItem.SlotID);
break;
case BUY_CONFIRM:
FreeSlot(&app_buy_confirm_array, TxnQItem.SlotID);
break;
case HOME:
FreeSlot(&app_home_array, TxnQItem.SlotID);
break;
case NEW_PRODUCTS:
FreeSlot(&app_new_products_array, TxnQItem.SlotID);
break;
case ORDER_DISPLAY:
FreeSlot(&app_order_display_array, TxnQItem.SlotID);
break;
case ORDER_INQUIRY:
FreeSlot(&app_order_inquiry_array, TxnQItem.SlotID);
break;
case PRODUCT_DETAIL:
FreeSlot(&app_product_detail_array, TxnQItem.SlotID);
break;
case SEARCH_REQUEST:
FreeSlot(&app_search_request_array, TxnQItem.SlotID);
break;
case SEARCH_RESULTS:
FreeSlot(&app_search_results_array, TxnQItem.SlotID);
break;
case SHOPPING_CART:
FreeSlot(&app_shopping_cart_array, TxnQItem.SlotID);
break;
}
return OK;
}
THREAD_CALL do_repeater(LPVOID lpParam)
{
char viewerbuf[IOBUFFER_SIZE]; /* viewer input buffer */
unsigned int viewerbuf_len = 0; /* available data in viewerbuf */
unsigned int viewerbuf_off = 0; /* offset in viewerbuf */
char serverbuf[IOBUFFER_SIZE]; /* server input buffer */
unsigned int serverbuf_len = 0; /* available data in serverbuf */
unsigned int serverbuf_off = 0; /* offset data in serverbuf */
repeaterslot *slot = (repeaterslot *)lpParam;
int len = 0, nfds = (slot->server > slot->viewer ? slot->server : slot->viewer)+1;
fd_set fds;
CARD8 client_init = 1;
logp(DEBUG, "do_reapeater(): Starting repeater for ID %d.", slot->code);
if (socket_write_exact(slot->server, (char *)&client_init, sz_rfbClientInitMsg) == sz_rfbClientInitMsg) {
logp(DEBUG, "Sent to server (socket=%d) ClientInitMsg", slot->server);
// Start the repeater loop (repeater between stdin/out and socket)
while(true)
{
/* Bypass reading if there is still data to be sent in the buffers */
if (serverbuf_len == 0 && viewerbuf_len == 0) {
FD_ZERO( &fds );
FD_SET(slot->server, &fds); /** prepare for reading server input **/
FD_SET(slot->viewer, &fds); /** prepare for reading viewer input **/
if (::select(nfds, &fds, NULL, NULL, NULL) < 0) {
logp(ERROR, "do_repeater(): input select() failed, errno=%d", getLastErrNo());
break;
}
/* server => viewer */
if (FD_ISSET(slot->server, &fds)) {
len = ::socket_read(slot->server, serverbuf, sizeof(serverbuf));
if (len > 0) {
serverbuf_len += len; /* repeat */
serverbuf_off = 0;
} else if (len < 0)
break;
}
/* viewer => server */
if ( FD_ISSET(slot->viewer, &fds) ) {
len = ::socket_read(slot->viewer, viewerbuf, sizeof(viewerbuf));
if (len > 0) {
viewerbuf_len += len; /* repeat */
viewerbuf_off = 0;
} else if (len < 0)
break;
}
}
if (viewerbuf_len > 0 || serverbuf_len > 0) {
FD_ZERO( &fds );
if (viewerbuf_len > 0) FD_SET(slot->server, &fds); /** prepare for reading server output **/
if (serverbuf_len > 0) FD_SET(slot->viewer, &fds); /** prepare for reading viewer output **/
if (::select(nfds, NULL, &fds, NULL, NULL) < 0) {
logp(ERROR, "do_repeater(): ouput select() failed, errno=%d", getLastErrNo());
break;
}
/* flush data in viewerbuffer to server */
if ( FD_ISSET(slot->server, &fds) ) {
len = ::socket_write(slot->server, viewerbuf+viewerbuf_off, viewerbuf_len);
if (len > 0) {
viewerbuf_len -= len;
viewerbuf_off += len;
} else if (len < 0)
break;
}
/* flush data in serverbuffer to viewer */
if ( FD_ISSET(slot->viewer, &fds) ) {
len = ::socket_write(slot->viewer, serverbuf+serverbuf_off, serverbuf_len);
if (len > 0) {
serverbuf_len -= len;
serverbuf_off += len;
} else if (len < 0)
break;
}
}
}
} else
logp(ERROR, "do_repeater(): Writting the ClientInit message to server (socket=%d) returned socket error %d.", slot->server, getLastErrNo());
/** When the thread exits **/
FreeSlot(slot);
logp(INFO, "do_reapeater(): Repeater for ID %d closed.", slot->code);
return 0;
}
/*
=================
UI_StatusEvent
A server status response has been received, validated and parsed.
=================
*/
void UI_StatusEvent(const serverStatus_t *status)
{
serverslot_t *slot;
char *hostname, *host, *mod, *map, *maxclients;
unsigned timestamp, ping;
const char *info = status->infostring;
char key[MAX_INFO_STRING];
char value[MAX_INFO_STRING];
int i;
// ignore unless menu is up
if (!m_servers.args) {
return;
}
// see if already added
slot = FindSlot(&net_from, &i);
if (!slot) {
// reply to broadcast, create new slot
if (m_servers.list.numItems >= MAX_STATUS_SERVERS) {
return;
}
m_servers.list.numItems++;
hostname = UI_CopyString(NET_AdrToString(&net_from));
timestamp = m_servers.timestamp;
} else {
// free previous data
hostname = slot->hostname;
timestamp = slot->timestamp;
FreeSlot(slot);
}
host = Info_ValueForKey(info, "hostname");
if (COM_IsWhite(host)) {
host = hostname;
}
mod = Info_ValueForKey(info, "game");
if (COM_IsWhite(mod)) {
mod = "baseq2";
}
map = Info_ValueForKey(info, "mapname");
if (COM_IsWhite(map)) {
map = "???";
}
maxclients = Info_ValueForKey(info, "maxclients");
if (!COM_IsUint(maxclients)) {
maxclients = "?";
}
if (timestamp > com_eventTime)
timestamp = com_eventTime;
ping = com_eventTime - timestamp;
if (ping > 999)
ping = 999;
slot = UI_FormatColumns(SLOT_EXTRASIZE, host, mod, map,
va("%d/%s", status->numPlayers, maxclients),
va("%u", ping),
NULL);
slot->status = SLOT_VALID;
slot->address = net_from;
slot->hostname = hostname;
slot->color = ColorForStatus(status, ping);
m_servers.list.items[i] = slot;
slot->numRules = 0;
while (slot->numRules < MAX_STATUS_RULES) {
Info_NextPair(&info, key, value);
if (!info)
break;
if (!key[0])
strcpy(key, "<MISSING KEY>");
if (!value[0])
strcpy(value, "<MISSING VALUE>");
slot->rules[slot->numRules++] =
UI_FormatColumns(0, key, value, NULL);
}
slot->numPlayers = status->numPlayers;
for (i = 0; i < status->numPlayers; i++) {
slot->players[i] =
UI_FormatColumns(0,
va("%d", status->players[i].score),
va("%d", status->players[i].ping),
status->players[i].name,
NULL);
}
slot->timestamp = timestamp;
// don't sort when manually refreshing
if (m_servers.pingstage)
m_servers.list.sort(&m_servers.list);
UpdateStatus();
UpdateSelection();
}
