/**
* Close a socket and remove it from the select list.
* @param socket the socket to close
* @return completion code
*/
void Socket_close(int socket)
{
FUNC_ENTRY;
Socket_close_only(socket);
FD_CLR(socket, &(s.rset_saved));
if (FD_ISSET(socket, &(s.pending_wset)))
FD_CLR(socket, &(s.pending_wset));
if (s.cur_clientsds != NULL && *(int*)(s.cur_clientsds->content) == socket)
s.cur_clientsds = s.cur_clientsds->next;
ListRemoveItem(s.connect_pending, &socket, intcompare);
ListRemoveItem(s.write_pending, &socket, intcompare);
SocketBuffer_cleanup(socket);
if (ListRemoveItem(s.clientsds, &socket, intcompare))
Log(TRACE_MIN, -1, "Removed socket %d", socket);
else
Log(TRACE_MIN, -1, "Failed to remove socket %d", socket);
if (socket + 1 >= s.maxfdp1)
{
/* now we have to reset s.maxfdp1 */
ListElement* cur_clientsds = NULL;
s.maxfdp1 = 0;
while (ListNextElement(s.clientsds, &cur_clientsds))
s.maxfdp1 = max(*((int*)(cur_clientsds->content)), s.maxfdp1);
++(s.maxfdp1);
Log(TRACE_MAX, -1, "Reset max fdp1 to %d", s.maxfdp1);
}
FUNC_EXIT;
}
/**
* Don't accept work from a client unless it is accepting work back, i.e. its socket is writeable
* this seems like a reasonable form of flow control, and practically, seems to work.
* @param socket the socket to check
* @param read_set the socket read set (see select doc)
* @param write_set the socket write set (see select doc)
* @return boolean - is the socket ready to go?
*/
int isReady(int socket, fd_set* read_set, fd_set* write_set)
{
int rc = 1;
FUNC_ENTRY;
if (ListFindItem(s.connect_pending, &socket, intcompare) && FD_ISSET(socket, write_set))
ListRemoveItem(s.connect_pending, &socket, intcompare);
else
rc = FD_ISSET(socket, read_set) && FD_ISSET(socket, write_set) && Socket_noPendingWrites(socket);
FUNC_EXIT_RC(rc);
return rc;
}
int main(int argc, char *argv[])
{
int i, *ip, *todelete;
ListElement* current = NULL;
List* l = ListInitialize();
printf("List initialized\n");
for (i = 0; i < 10; i++)
{
ip = malloc(sizeof(int));
*ip = i;
ListAppend(l, (void*)ip, sizeof(int));
if (i==5)
todelete = ip;
printf("List element appended %d\n", *((int*)(l->last->content)));
}
printf("List contents:\n");
current = NULL;
while (ListNextElement(l, ¤t) != NULL)
printf("List element: %d\n", *((int*)(current->content)));
printf("List contents in reverse order:\n");
current = NULL;
while (ListPrevElement(l, ¤t) != NULL)
printf("List element: %d\n", *((int*)(current->content)));
//if ListFindItem(l, *ip, intcompare)->content
printf("List contents having deleted element %d:\n", *todelete);
ListRemove(l, todelete);
current = NULL;
while (ListNextElement(l, ¤t) != NULL)
printf("List element: %d\n", *((int*)(current->content)));
i = 9;
ListRemoveItem(l, &i, intcompare);
printf("List contents having deleted another element, %d, size now %d:\n", i, l->size);
current = NULL;
while (ListNextElement(l, ¤t) != NULL)
printf("List element: %d\n", *((int*)(current->content)));
ListFree(l);
printf("List freed\n");
}
int device_deregister(char *devname)
{
int i,l,dev_index;
device_t *dev = NULL;
char temp_names[3][8];
dev_index=-1;
for (i=1; i<=ListNumItems(devlist); i++) {
dev = ListGetPtrToItem (devlist, i);
if(strcmp(dev->name,devname)==0) {
dev_index=i;
break;
}
}
if(dev_index<0) /* device not found */
return 0;
/* get stdio devices (ListRemoveItem changes the dev list) */
for (l=0 ; l< MAX_FILES; l++) {
if (stdio_devices[l] == dev) {
/* Device is assigned -> report error */
return -1;
}
memcpy (&temp_names[l][0],
stdio_devices[l]->name,
sizeof(stdio_devices[l]->name));
}
ListRemoveItem(devlist,NULL,dev_index);
/* reassign Device list */
for (i=1; i<=ListNumItems(devlist); i++) {
dev = ListGetPtrToItem (devlist, i);
for (l=0 ; l< MAX_FILES; l++) {
if(strcmp(dev->name,temp_names[l])==0) {
stdio_devices[l] = dev;
}
}
}
return 0;
}
static BOOL disconnectSinkVChan (SinkVChan_type* sinkVChan)
{
if (!sinkVChan) return FALSE;
SinkVChan_type* connectedSinkVChan = NULL;
SourceVChan_type* srcVChan = sinkVChan->sourceVChan;
if (!srcVChan) return TRUE; // do nothing if there is no source to disconnect
// remove Source VChan from Sink VChan
sinkVChan->sourceVChan = NULL;
// if Sink VChan is open, close it
if (sinkVChan->baseClass.isOpen) {
sinkVChan->baseClass.isOpen = VChan_Closed;
if (sinkVChan->baseClass.VChanStateChangeCBFptr)
(*sinkVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)sinkVChan, sinkVChan->baseClass.VChanOwner, sinkVChan->baseClass.isOpen);
}
// remove Sink VChan from Source VChan
for (size_t i = 1; i <= ListNumItems(srcVChan->sinkVChans); i++) {
connectedSinkVChan = *(SinkVChan_type**)ListGetPtrToItem(srcVChan->sinkVChans, i);
if (connectedSinkVChan == sinkVChan) {
ListRemoveItem(srcVChan->sinkVChans, 0, i);
// if Source VChan is open and there are no more active Sinks, then close Source VChan
if (srcVChan->baseClass.isOpen && !GetNumActiveSinkVChans(srcVChan)) {
srcVChan->baseClass.isOpen = VChan_Closed;
if (srcVChan->baseClass.VChanStateChangeCBFptr)
(*srcVChan->baseClass.VChanStateChangeCBFptr) ((VChan_type*)srcVChan, srcVChan->baseClass.VChanOwner, srcVChan->baseClass.isOpen);
}
return TRUE;
}
}
return FALSE;
}
void ListRemoveDuplicates (list_t list, CompareFunction compareFunction)
{
int numItems, index, startIndexForFind, duplicatesIndex;
numItems = ListNumItems (list);
for (index = 1; index < numItems; index++) {
startIndexForFind = index + 1;
while (startIndexForFind <= numItems) {
duplicatesIndex =
ListFindItem (list,
ListGetPtrToItem (list, index),
startIndexForFind,
compareFunction);
if (duplicatesIndex > 0) {
ListRemoveItem (list, NULL, duplicatesIndex);
numItems--;
startIndexForFind = duplicatesIndex;
} else {
break;
}
}
}
}
/**
* A socket write has now completed so we can get rid of the queue
* @param socket the socket for which the operation is now complete
* @return completion code, boolean - was the queue removed?
*/
int SocketBuffer_writeComplete(int socket)
{
return ListRemoveItem(&writes, &socket, pending_socketcompare);
}
