kresolvermanager.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "config.h"
00026
00027 #include <sys/types.h>
00028 #include <netinet/in.h>
00029 #include <limits.h>
00030 #include <unistd.h>
00031
00032 #ifdef HAVE_RES_INIT
00033 # include <sys/stat.h>
00034 # include <resolv.h>
00035 #endif
00036
00037 #include <qapplication.h>
00038 #include <qstring.h>
00039 #include <qcstring.h>
00040 #include <qptrlist.h>
00041 #include <qtimer.h>
00042 #include <qmutex.h>
00043 #include <qthread.h>
00044 #include <qwaitcondition.h>
00045 #include <qsemaphore.h>
00046
00047 #include "kresolver.h"
00048 #include "kresolver_p.h"
00049 #include "kresolverworkerbase.h"
00050 #include "kresolverstandardworkers_p.h"
00051
00052 using namespace KNetwork;
00053 using namespace KNetwork::Internal;
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101 namespace
00102 {
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114 class ResInitUsage
00115 {
00116 #ifdef HAVE_RES_INIT
00117 time_t mTime;
00118 QWaitCondition cond;
00119 QMutex mutex;
00120 int useCount;
00121
00122 bool shouldResInit()
00123 {
00124
00125 struct stat st;
00126 if (stat("/etc/resolv.conf", &st) != 0)
00127 return false;
00128
00129 if (mTime < st.st_mtime)
00130 {
00131
00132 return true;
00133 }
00134 return false;
00135 }
00136
00137 void reResInit()
00138 {
00139
00140 res_init();
00141
00142 struct stat st;
00143 if (stat("/etc/resolv.conf", &st) == 0)
00144 mTime = st.st_mtime;
00145 }
00146
00147 public:
00148 ResInitUsage()
00149 : mTime(0), useCount(0)
00150 { }
00151
00152
00153
00154
00155 void operator--(int)
00156 {
00157 mutex.lock();
00158 if (--useCount == 0)
00159
00160 cond.wakeAll();
00161 mutex.unlock();
00162 }
00163
00164
00165
00166
00167 void operator++(int)
00168 {
00169 mutex.lock();
00170
00171 if (shouldResInit())
00172 {
00173 if (useCount)
00174 {
00175
00176
00177
00178 cond.wait(&mutex);
00179 }
00180 reResInit();
00181 }
00182 useCount++;
00183 mutex.unlock();
00184 }
00185
00186 #else
00187 public:
00188 ResInitUsage()
00189 { }
00190
00191 void operator--(int)
00192 { }
00193
00194 void operator++(int)
00195 { }
00196 #endif
00197
00198 } resInit;
00199
00200 }
00201
00202
00203
00204
00205
00206
00207
00208 static const int maxThreadWaitTime = ULONG_MAX;
00209 static const int maxThreads = 5;
00210
00211 static pid_t pid;
00212
00213 KResolverThread::KResolverThread()
00214 : data(0L)
00215 {
00216 }
00217
00218
00219 void KResolverThread::run()
00220 {
00221
00222
00223
00224
00225 KResolverManager::manager()->registerThread(this);
00226 while (true)
00227 {
00228 data = KResolverManager::manager()->requestData(this, ::maxThreadWaitTime);
00229
00230
00231 if (data)
00232 {
00233
00234
00235
00236
00237 ;
00238
00239
00240 data->worker->run();
00241
00242
00243 KResolverManager::manager()->releaseData(this, data);
00244
00245
00246 }
00247 else
00248 break;
00249 }
00250
00251 KResolverManager::manager()->unregisterThread(this);
00252
00253 }
00254
00255 static KResolverManager *globalManager;
00256
00257 KResolverManager* KResolverManager::manager()
00258 {
00259 if (globalManager == 0L)
00260 new KResolverManager();
00261 return globalManager;
00262 }
00263
00264 KResolverManager::KResolverManager()
00265 : runningThreads(0), availableThreads(0)
00266 {
00267 globalManager = this;
00268 workers.setAutoDelete(true);
00269 currentRequests.setAutoDelete(true);
00270 initStandardWorkers();
00271
00272 pid = getpid();
00273 }
00274
00275 KResolverManager::~KResolverManager()
00276 {
00277
00278
00279
00280 for (workers.first(); workers.current(); workers.next())
00281 workers.current()->terminate();
00282 }
00283
00284 void KResolverManager::registerThread(KResolverThread* )
00285 {
00286 }
00287
00288 void KResolverManager::unregisterThread(KResolverThread*)
00289 {
00290 }
00291
00292
00293 RequestData* KResolverManager::requestData(KResolverThread *th, int maxWaitTime)
00294 {
00296
00298
00299 resInit++;
00300
00301
00302
00303 QMutexLocker locker(&mutex);
00304 RequestData *data = findData(th);
00305
00306 if (data)
00307
00308 return data;
00309
00310
00311 availableThreads++;
00312 feedWorkers.wait(&mutex, maxWaitTime);
00313 availableThreads--;
00314
00315 data = findData(th);
00316 if (data == 0L)
00317 {
00318
00319 runningThreads--;
00320 resInit--;
00321 }
00322 return data;
00323 }
00324
00325 RequestData* KResolverManager::findData(KResolverThread* th)
00326 {
00328
00329
00331
00332
00333 for (RequestData *curr = newRequests.first(); curr; curr = newRequests.next())
00334 if (!curr->worker->m_finished)
00335 {
00336
00337 if (curr->obj)
00338 curr->obj->status = KResolver::InProgress;
00339 curr->worker->th = th;
00340
00341
00342 currentRequests.append(newRequests.take());
00343
00344 return curr;
00345 }
00346
00347
00348 return 0L;
00349 }
00350
00351
00352 void KResolverManager::releaseData(KResolverThread *, RequestData* data)
00353 {
00355
00357
00358 resInit--;
00359
00360
00361
00362
00363 if (data->obj)
00364 {
00365 data->obj->status = KResolver::PostProcessing;
00366 }
00367
00368 data->worker->m_finished = true;
00369 data->worker->th = 0L;
00370
00371
00372 handleFinished();
00373 }
00374
00375
00376 void KResolverManager::handleFinished()
00377 {
00378 bool redo = false;
00379 QPtrQueue<RequestData> doneRequests;
00380
00381 mutex.lock();
00382
00383
00384
00385
00386 RequestData *curr = currentRequests.last();
00387 while (curr)
00388 {
00389 if (curr->worker->th == 0L)
00390 {
00391 if (handleFinishedItem(curr))
00392 {
00393 doneRequests.enqueue(currentRequests.take());
00394 if (curr->requestor &&
00395 curr->requestor->nRequests == 0 &&
00396 curr->requestor->worker->m_finished)
00397
00398 redo = true;
00399 }
00400 }
00401
00402 curr = currentRequests.prev();
00403 }
00404
00405
00406 while (RequestData *d = doneRequests.dequeue())
00407 doNotifying(d);
00408
00409 mutex.unlock();
00410
00411 if (redo)
00412 {
00413
00414
00415 handleFinished();
00416 }
00417 }
00418
00419
00420 bool KResolverManager::handleFinishedItem(RequestData* curr)
00421
00422 {
00423
00424
00425
00426 if (curr->worker->m_finished && curr->nRequests == 0)
00427 {
00428
00429 if (curr->obj)
00430 curr->obj->status = KResolver::PostProcessing;
00431
00432 if (curr->requestor)
00433 --curr->requestor->nRequests;
00434
00435
00436
00437 return true;
00438 }
00439 return false;
00440 }
00441
00442
00443
00444 void KResolverManager::registerNewWorker(KResolverWorkerFactoryBase *factory)
00445 {
00446 workerFactories.append(factory);
00447 }
00448
00449 KResolverWorkerBase* KResolverManager::findWorker(KResolverPrivate* p)
00450 {
00452
00454
00455
00456
00457
00458
00459
00460
00461
00462
00463
00464 KResolverWorkerBase *worker;
00465 for (KResolverWorkerFactoryBase *factory = workerFactories.first(); factory;
00466 factory = workerFactories.next())
00467 {
00468 worker = factory->create();
00469
00470
00471 worker->input = &p->input;
00472
00473 if (worker->preprocess())
00474 {
00475
00476 if (worker->m_finished)
00477 p->status = KResolver::PostProcessing;
00478 else
00479 p->status = KResolver::Queued;
00480 return worker;
00481 }
00482
00483
00484 delete worker;
00485 }
00486
00487
00488 return 0L;
00489 }
00490
00491 void KResolverManager::doNotifying(RequestData *p)
00492 {
00494
00495
00497
00498
00499
00500
00501
00502
00503
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519 if (p->obj)
00520 {
00521
00522 p->obj->mutex.lock();
00523 KResolver* parent = p->obj->parent;
00524 KResolverResults& r = p->obj->results;
00525
00526 if (p->obj->status == KResolver::Canceled)
00527 {
00528 p->obj->status = KResolver::Canceled;
00529 p->obj->errorcode = KResolver::Canceled;
00530 p->obj->syserror = 0;
00531 r.setError(KResolver::Canceled, 0);
00532 }
00533 else if (p->worker)
00534 {
00535
00536 p->worker->postprocess();
00537
00538
00539
00540 r = p->worker->results;
00541
00542
00543 r.setAddress(p->input->node, p->input->service);
00544
00545
00546
00547
00548 p->obj->errorcode = r.error();
00549 p->obj->syserror = r.systemError();
00550 p->obj->status = !r.isEmpty() ?
00551 KResolver::Success : KResolver::Failed;
00552 }
00553 else
00554 {
00555 r.empty();
00556 r.setError(p->obj->errorcode, p->obj->syserror);
00557 }
00558
00559
00560 if (!p->obj->waiting && parent)
00561
00562
00563
00564 QApplication::postEvent(parent, new QEvent((QEvent::Type)(ResolutionCompleted)));
00565
00566
00567 p->obj->mutex.unlock();
00568 }
00569 else
00570 {
00571
00572 if (p->worker)
00573 p->worker->postprocess();
00574 }
00575
00576 delete p->worker;
00577
00578
00579
00580
00581 delete p;
00582
00583
00584 notifyWaiters.wakeAll();
00585 }
00586
00587
00588
00589
00590 void KResolverManager::enqueue(KResolver *obj, RequestData *requestor)
00591 {
00592 RequestData *newrequest = new RequestData;
00593 newrequest->nRequests = 0;
00594 newrequest->obj = obj->d;
00595 newrequest->input = &obj->d->input;
00596 newrequest->requestor = requestor;
00597
00598
00599
00600 if ((newrequest->worker = findWorker(obj->d)) == 0L)
00601 {
00602
00603
00604 obj->d->status = KResolver::Failed;
00605 obj->d->errorcode = KResolver::UnsupportedFamily;
00606 obj->d->syserror = 0;
00607
00608 doNotifying(newrequest);
00609 return;
00610 }
00611
00612
00613
00614 if (requestor)
00615 requestor->nRequests++;
00616
00617 if (!newrequest->worker->m_finished)
00618 dispatch(newrequest);
00619 else if (newrequest->nRequests > 0)
00620 {
00621 mutex.lock();
00622 currentRequests.append(newrequest);
00623 mutex.unlock();
00624 }
00625 else
00626
00627 doNotifying(newrequest);
00628 }
00629
00630
00631
00632 void KResolverManager::dispatch(RequestData *data)
00633 {
00634
00635
00636
00637
00638 QMutexLocker locker(&mutex);
00639
00640
00641 newRequests.append(data);
00642
00643
00644
00645
00646
00647
00648
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669 if (availableThreads == 0 && runningThreads < maxThreads)
00670 {
00671
00672
00673
00674 KResolverThread *th = workers.first();
00675 while (th && th->running())
00676 th = workers.next();
00677
00678 if (th == 0L)
00679
00680 th = new KResolverThread;
00681 else
00682 workers.take();
00683
00684 th->start();
00685 workers.append(th);
00686 runningThreads++;
00687 }
00688
00689 feedWorkers.wakeAll();
00690
00691
00692 workers.first();
00693 while (workers.current())
00694 {
00695 if (!workers.current()->running())
00696 workers.remove();
00697 else
00698 workers.next();
00699 }
00700 }
00701
00702
00703 bool KResolverManager::dequeueNew(KResolver* obj)
00704 {
00705
00706
00707
00708
00709 KResolverPrivate *d = obj->d;
00710
00711
00712 RequestData *curr = newRequests.first();
00713 while (curr)
00714 if (curr->obj == d)
00715 {
00716
00717
00718 d->status = KResolver::Canceled;
00719 d->errorcode = KResolver::Canceled;
00720 d->syserror = 0;
00721 newRequests.take();
00722
00723 delete curr->worker;
00724 delete curr;
00725
00726 return true;
00727 }
00728 else
00729 curr = newRequests.next();
00730
00731
00732 curr = currentRequests.first();
00733 while (curr)
00734 if (curr->obj == d)
00735 {
00736
00737
00738 d->mutex.lock();
00739
00740 d->status = KResolver::Canceled;
00741 d->errorcode = KResolver::Canceled;
00742 d->syserror = 0;
00743
00744
00745 curr->obj = 0L;
00746 curr->input = 0L;
00747 if (curr->worker)
00748 curr->worker->input = 0L;
00749
00750 d->mutex.unlock();
00751 }
00752 else
00753 curr = currentRequests.next();
00754
00755 return false;
00756 }
00757
00758
00759
00760 void KResolverManager::dequeue(KResolver *obj)
00761 {
00762 QMutexLocker locker(&mutex);
00763 dequeueNew(obj);
00764 }
This file is part of the documentation for kdecore Library Version 3.3.2.