bool FSDirectory::hasFile(const String &name) const {
if (name.empty() || !_node.isDirectory())
return false;
FSNode *node = lookupCache(_fileCache, name);
return node && node->exists();
}
FSDirectory *FSDirectory::getSubDirectory(const String &prefix, const String &name, int depth, bool flat) {
if (name.empty() || !_node.isDirectory())
return 0;
FSNode *node = lookupCache(_subDirCache, name);
if (!node)
return 0;
return new FSDirectory(prefix, *node, depth, flat);
}
SeekableReadStream *FSDirectory::createReadStreamForMember(const String &name) const {
if (name.empty() || !_node.isDirectory())
return 0;
FSNode *node = lookupCache(_fileCache, name);
if (!node)
return 0;
SeekableReadStream *stream = node->createReadStream();
if (!stream)
warning("FSDirectory::createReadStreamForMember: Can't create stream for file '%s'", name.c_str());
return stream;
}
const ArchiveMemberPtr FSDirectory::getMember(const String &name) const {
if (name.empty() || !_node.isDirectory())
return ArchiveMemberPtr();
FSNode *node = lookupCache(_fileCache, name);
if (!node || !node->exists()) {
warning("FSDirectory::getMember: '%s' does not exist", name.c_str());
return ArchiveMemberPtr();
} else if (node->isDirectory()) {
warning("FSDirectory::getMember: '%s' is a directory", name.c_str());
return ArchiveMemberPtr();
}
return ArchiveMemberPtr(new FSNode(*node));
}
QMatchData QUnsortedModelEngine::filter(const QString& part, const QModelIndex& parent, int n)
{
QMatchData hint;
QVector<int> v;
QIndexMapper im(v);
QMatchData m(im, -1, true);
const QAbstractItemModel *model = c->proxy->sourceModel();
bool foundInCache = lookupCache(part, parent, &m);
if (!foundInCache) {
if (matchHint(part, parent, &hint) && !hint.isValid())
return QMatchData();
}
if (!foundInCache && !hint.isValid()) {
const int lastRow = model->rowCount(parent) - 1;
QIndexMapper all(0, lastRow);
int lastIndex = buildIndices(part, parent, n, all, &m);
m.partial = (lastIndex != lastRow);
} else {
if (!foundInCache) { // build from hint as much as we can
buildIndices(part, parent, INT_MAX, hint.indices, &m);
m.partial = hint.partial;
}
if (m.partial && ((n == -1 && m.exactMatchIndex == -1) || (m.indices.count() < n))) {
// need more and have more
const int lastRow = model->rowCount(parent) - 1;
QIndexMapper rest(hint.indices.last() + 1, lastRow);
int want = n == -1 ? -1 : n - m.indices.count();
int lastIndex = buildIndices(part, parent, want, rest, &m);
m.partial = (lastRow != lastIndex);
}
}
saveInCache(part, parent, m);
return m;
}
int main(int argc, char **argv)
{
int listenfd_tour, connfd_tour, n, i, slen, pfsock_arp, t_ifindex, t_hatype;
char sendtomac[18], recvline[MAXLINE], t_hwaddr[18], partialIP[16];
char reqhost[100],rephost[100];
struct hwaddr replyToTour;
socklen_t clilen;
struct sockaddr_un cliaddr, servaddr;
struct sockaddr_ll saddr;
struct s_arppkt *pkt_recd;
struct s_ARP_cache *curr;
void *buffer = (void *)malloc(ETH_FRAME_LEN);
int flagBroadcasted = 0;
strcpy(partialIP,"");
//Declaration for Select
fd_set rset;
int maxfd;
ifhead = NULL;
ARP_cache_head = NULL;
printf("ARP process started.\n");
createIfList();
printIfaces();
pfsock_arp = Socket(PF_PACKET, SOCK_RAW, htons(USID_PROTO));
listenfd_tour = Socket(AF_LOCAL, SOCK_STREAM, 0);
unlink(ARP_PATH);
bzero(&servaddr, sizeof(servaddr));
servaddr.sun_family = AF_LOCAL;
strcpy(servaddr.sun_path, ARP_PATH);
Bind(listenfd_tour, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd_tour, LISTENQ);
for(;;)
{
FD_ZERO(&rset);
FD_SET(listenfd_tour,&rset); //For other ARPs
FD_SET(pfsock_arp,&rset);
if( flagBroadcasted == 1)
{
FD_SET(connfd_tour,&rset);
maxfd = max(listenfd_tour, max(pfsock_arp, connfd_tour)) + 1;
}
else
maxfd = max(listenfd_tour,pfsock_arp) + 1;
if( (select(maxfd,&rset,NULL,NULL,NULL)) < 0)
{
if(errno == EINTR)
continue;
else
{
printf("Error in select, errno : %s ! Exitting the program\n",strerror(errno));
exit(-1);
}
}
// ARP request from tour
if(FD_ISSET(listenfd_tour,&rset))
{
clilen = sizeof(cliaddr);
if ( (connfd_tour = accept(listenfd_tour, (SA *) &cliaddr, &clilen)) < 0) {
printf("Accept error, quitting!\n");
exit(-1);
}
flagBroadcasted = 1;
}
else if(FD_ISSET(connfd_tour,&rset))
{
if( (n = recv(connfd_tour, (char *)recvline, MAXLINE, 0)) <= 0 )
{
#ifdef DEBUG
printf("Tour has ended\n");
#endif
for(curr = ARP_cache_head; curr != NULL; curr = curr->next)
deleteFromARPCache(partialIP);
flagBroadcasted = 0;
strcpy(partialIP,"");
close(connfd_tour);
continue;
}
recvline[n] = 0 ;
#ifdef DEBUG
printf("Received from tour: %s\n",recvline);
#endif
strcpy(partialIP, recvline);
lookupCache(recvline, t_hwaddr, &t_ifindex, &t_hatype);
#ifdef DEBUG
printf("Lookup of ARP Cache, found : %s, %s\n", recvline, t_hwaddr);
#endif
if( strcmp(t_hwaddr, "") == 0 )
{
//Need to find MAC address for IP in recvline
#ifdef DEBUG
printf("Entry not available in cache, broadcast required\n");
#endif
broadcastARPRequest(recvline, pfsock_arp);
}
else
{
replyToTour.sll_ifindex = t_ifindex;
replyToTour.sll_hatype = t_hatype;
replyToTour.sll_halen = sizeof(t_hatype);
sscanf(t_hwaddr, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
&replyToTour.sll_addr[0],&replyToTour.sll_addr[1],&replyToTour.sll_addr[2],&replyToTour.sll_addr[3],
&replyToTour.sll_addr[4],&replyToTour.sll_addr[5]);
replyToTour.sll_addr[6] = 0;
replyToTour.sll_addr[7] = 0;
printf("ARP entry for %s available in cache, not sending ARP request.Replying to tour with HW Address:%s\n",
findhostname(recvline), t_hwaddr);
send(connfd_tour, (void *)&replyToTour, sizeof(replyToTour), 0);
}
}
else
//Message from some other ARP
if(FD_ISSET(pfsock_arp, &rset))
{
#ifdef DEBUG
printf("Message received from other arp\n");
#endif
slen = sizeof(saddr);
if( (n = recvfrom(pfsock_arp, buffer, ETH_FRAME_LEN, 0, (SA *)&saddr, &slen)) < 0)
{
printf("Error receiving packet, errno: %s !Exitting the program\n",strerror(errno));
exit(-1);
}
else
{
#ifdef DEBUG
printf("Received packet from interface %d\n",saddr.sll_ifindex);
#endif
void *data = buffer + 14;
pkt_recd = (struct s_arppkt *) data;
if(pkt_recd->id != ARPPKT_ID)
{
#ifdef DEBUG
printf("Received packet with unknown id %d, ignoring!\n",pkt_recd->id);
#endif
continue;
}
switch(pkt_recd->op)
{
case TYPE_REQ:
#ifdef DEBUG
printf("Received request\n");
#endif
if(strcmp(pkt_recd->dst_ip, ifhead->ipaddr) == 0)
{
sprintf(t_hwaddr, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
pkt_recd->src_mac[0], pkt_recd->src_mac[1], pkt_recd->src_mac[2],
pkt_recd->src_mac[3], pkt_recd->src_mac[4], pkt_recd->src_mac[5]);
insertToARPCache(pkt_recd->src_ip, t_hwaddr, saddr.sll_ifindex, MAC_HATYPE, pfsock_arp);
#ifdef DEBUG
printARPCache();
#endif
strcpy(rephost, findhostname(pkt_recd->dst_ip));
strcpy(reqhost, findhostname(pkt_recd->src_ip));
printf("ARP REQUEST RECEIVED:\n");
printf("Src: %s Dst: ff:ff:ff:ff:ff:ff arp 60:\n",
t_hwaddr);
printf("arp who-has %s tell %s\n", reqhost, rephost);
sendARPReply(pfsock_arp, pkt_recd->src_mac, saddr.sll_ifindex, pkt_recd->src_ip);
}
break;
case TYPE_REP:
#ifdef DEBUG
printf("ARP Reply received from %s to %s\n", pkt_recd->src_mac, pkt_recd->dst_mac);
#endif
sprintf(t_hwaddr, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
pkt_recd->src_mac[0], pkt_recd->src_mac[1], pkt_recd->src_mac[2],
pkt_recd->src_mac[3], pkt_recd->src_mac[4], pkt_recd->src_mac[5]);
updateCache(pkt_recd->src_ip, t_hwaddr, saddr.sll_ifindex, MAC_HATYPE, pfsock_arp);
#ifdef DEBUG
printARPCache();
#endif
strcpy(rephost,findhostname(pkt_recd->src_ip));
printf("ARP REPLY RECEIVED:\n");
printf("Src: %s Dst: %s arp 60:\n", pkt_recd->src_mac, pkt_recd->dst_mac);
printf("arp reply %s is-at %s\n", rephost, t_hwaddr);
replyToTour.sll_ifindex = saddr.sll_ifindex;
replyToTour.sll_hatype = MAC_HATYPE;
replyToTour.sll_halen = sizeof(replyToTour.sll_hatype);
for(i=0; i<6; i++)
replyToTour.sll_addr[i] = pkt_recd->src_mac[i];
replyToTour.sll_addr[6] = 0;
replyToTour.sll_addr[7] = 0;
send(connfd_tour, (void *)&replyToTour, sizeof(replyToTour), 0);
flagBroadcasted = 0;
strcpy(partialIP,"");
close(connfd_tour);
break;
default:
printf("Weird ARP Packet received, type : %d, discarding!\n", pkt_recd->op);
break;
}
}
}
}
printf("ARP quitting\n");
return 1;
}
QMatchData QSortedModelEngine::filter(const QString& part, const QModelIndex& parent, int)
{
const QAbstractItemModel *model = c->proxy->sourceModel();
QMatchData hint;
if (lookupCache(part, parent, &hint))
return hint;
QIndexMapper indices;
Qt::SortOrder order = sortOrder(parent);
if (matchHint(part, parent, &hint)) {
if (!hint.isValid())
return QMatchData();
indices = hint.indices;
} else {
indices = indexHint(part, parent, order);
}
// binary search the model within 'indices' for 'part' under 'parent'
int high = indices.to() + 1;
int low = indices.from() - 1;
int probe;
QModelIndex probeIndex;
QString probeData;
while (high - low > 1)
{
probe = (high + low) / 2;
probeIndex = model->index(probe, c->column, parent);
probeData = model->data(probeIndex, c->role).toString();
const int cmp = QString::compare(probeData, part, c->cs);
if ((order == Qt::AscendingOrder && cmp >= 0)
|| (order == Qt::DescendingOrder && cmp < 0)) {
high = probe;
} else {
low = probe;
}
}
if ((order == Qt::AscendingOrder && low == indices.to())
|| (order == Qt::DescendingOrder && high == indices.from())) { // not found
saveInCache(part, parent, QMatchData());
return QMatchData();
}
probeIndex = model->index(order == Qt::AscendingOrder ? low+1 : high-1, c->column, parent);
probeData = model->data(probeIndex, c->role).toString();
if (!probeData.startsWith(part, c->cs)) {
saveInCache(part, parent, QMatchData());
return QMatchData();
}
const bool exactMatch = QString::compare(probeData, part, c->cs) == 0;
int emi = exactMatch ? (order == Qt::AscendingOrder ? low+1 : high-1) : -1;
int from = 0;
int to = 0;
if (order == Qt::AscendingOrder) {
from = low + 1;
high = indices.to() + 1;
low = from;
} else {
to = high - 1;
low = indices.from() - 1;
high = to;
}
while (high - low > 1)
{
probe = (high + low) / 2;
probeIndex = model->index(probe, c->column, parent);
probeData = model->data(probeIndex, c->role).toString();
const bool startsWith = probeData.startsWith(part, c->cs);
if ((order == Qt::AscendingOrder && startsWith)
|| (order == Qt::DescendingOrder && !startsWith)) {
low = probe;
} else {
high = probe;
}
}
QMatchData m(order == Qt::AscendingOrder ? QIndexMapper(from, high - 1) : QIndexMapper(low+1, to), emi, false);
saveInCache(part, parent, m);
return m;
}
