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 if (data->nRequests > 0)
00366
00367
00368 data->obj->status = KResolver::PostProcessing;
00369 else
00370
00371 data->obj->status = data->worker->results.isEmpty() ? KResolver::Failed : KResolver::Success;
00372 }
00373
00374 data->worker->m_finished = true;
00375 data->worker->th = 0L;
00376
00377
00378 handleFinished();
00379 }
00380
00381
00382 void KResolverManager::handleFinished()
00383 {
00384 bool redo = false;
00385 QPtrQueue<RequestData> doneRequests;
00386
00387 mutex.lock();
00388
00389
00390
00391
00392 RequestData *curr = currentRequests.last();
00393 while (curr)
00394 {
00395 if (curr->worker->th == 0L)
00396 {
00397 if (handleFinishedItem(curr))
00398 {
00399 doneRequests.enqueue(currentRequests.take());
00400 if (curr->requestor &&
00401 curr->requestor->nRequests == 0 &&
00402 curr->requestor->worker->m_finished)
00403
00404 redo = true;
00405 }
00406 }
00407
00408 curr = currentRequests.prev();
00409 }
00410
00411
00412 while (RequestData *d = doneRequests.dequeue())
00413 doNotifying(d);
00414
00415 mutex.unlock();
00416
00417 if (redo)
00418 {
00419
00420
00421 handleFinished();
00422 }
00423 }
00424
00425
00426 bool KResolverManager::handleFinishedItem(RequestData* curr)
00427
00428 {
00429
00430
00431
00432 if (curr->worker->m_finished && curr->nRequests == 0)
00433 {
00434
00435 if (curr->obj)
00436 curr->obj->status = KResolver::Success;
00437
00438 if (curr->requestor)
00439 --curr->requestor->nRequests;
00440
00441
00442
00443 return true;
00444 }
00445 return false;
00446 }
00447
00448
00449
00450 void KResolverManager::registerNewWorker(KResolverWorkerFactoryBase *factory)
00451 {
00452 workerFactories.append(factory);
00453 }
00454
00455 KResolverWorkerBase* KResolverManager::findWorker(KResolverPrivate* p)
00456 {
00458
00460
00461
00462
00463
00464
00465
00466
00467
00468
00469
00470 KResolverWorkerBase *worker;
00471 for (KResolverWorkerFactoryBase *factory = workerFactories.first(); factory;
00472 factory = workerFactories.next())
00473 {
00474 worker = factory->create();
00475
00476
00477 worker->input = &p->input;
00478
00479 if (worker->preprocess())
00480 {
00481
00482 if (worker->m_finished)
00483 p->status = !worker->results.isEmpty() ?
00484 KResolver::Success : KResolver::Failed;
00485 else
00486 p->status = KResolver::Queued;
00487 return worker;
00488 }
00489
00490
00491 delete worker;
00492 }
00493
00494
00495 return 0L;
00496 }
00497
00498 void KResolverManager::doNotifying(RequestData *p)
00499 {
00501
00502
00504
00505
00506
00507
00508
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518
00519
00520
00521
00522
00523
00524
00525
00526 if (p->obj)
00527 {
00528
00529 p->obj->mutex.lock();
00530 KResolver* parent = p->obj->parent;
00531 KResolverResults& r = p->obj->results;
00532
00533 if (p->obj->status == KResolver::Canceled)
00534 {
00535 p->obj->status = KResolver::Canceled;
00536 p->obj->errorcode = KResolver::Canceled;
00537 p->obj->syserror = 0;
00538 r.setError(KResolver::Canceled, 0);
00539 }
00540 else if (p->worker)
00541 {
00542
00543 p->worker->postprocess();
00544
00545
00546
00547 r = p->worker->results;
00548
00549
00550 r.setAddress(p->input->node, p->input->service);
00551
00552
00553
00554
00555 p->obj->errorcode = r.error();
00556 p->obj->syserror = r.systemError();
00557 p->obj->status = !r.isEmpty() ?
00558 KResolver::Success : KResolver::Failed;
00559 }
00560 else
00561 {
00562 r.empty();
00563 r.setError(p->obj->errorcode, p->obj->syserror);
00564 }
00565
00566
00567 if (!p->obj->waiting && parent)
00568
00569
00570
00571 QApplication::postEvent(parent, new QEvent((QEvent::Type)(ResolutionCompleted)));
00572
00573
00574 p->obj->mutex.unlock();
00575 }
00576 else
00577 {
00578
00579 if (p->worker)
00580 p->worker->postprocess();
00581 }
00582
00583 delete p->worker;
00584
00585
00586
00587
00588 delete p;
00589
00590
00591 notifyWaiters.wakeAll();
00592 }
00593
00594
00595
00596
00597 void KResolverManager::enqueue(KResolver *obj, RequestData *requestor)
00598 {
00599 RequestData *newrequest = new RequestData;
00600 newrequest->nRequests = 0;
00601 newrequest->obj = obj->d;
00602 newrequest->input = &obj->d->input;
00603 newrequest->requestor = requestor;
00604
00605
00606
00607 if ((newrequest->worker = findWorker(obj->d)) == 0L)
00608 {
00609
00610
00611 obj->d->status = KResolver::Failed;
00612 obj->d->errorcode = KResolver::UnsupportedFamily;
00613 obj->d->syserror = 0;
00614
00615 doNotifying(newrequest);
00616 return;
00617 }
00618
00619
00620
00621 if (requestor)
00622 requestor->nRequests++;
00623
00624 if (!newrequest->worker->m_finished)
00625 dispatch(newrequest);
00626 else if (newrequest->nRequests > 0)
00627 {
00628 mutex.lock();
00629 currentRequests.append(newrequest);
00630 mutex.unlock();
00631 }
00632 else
00633
00634 doNotifying(newrequest);
00635 }
00636
00637
00638
00639 void KResolverManager::dispatch(RequestData *data)
00640 {
00641
00642
00643
00644
00645 QMutexLocker locker(&mutex);
00646
00647
00648 newRequests.append(data);
00649
00650
00651
00652
00653
00654
00655
00656
00657
00658
00659
00660
00661
00662
00663
00664
00665
00666
00667
00668
00669
00670
00671
00672
00673
00674
00675
00676 if (availableThreads == 0 && runningThreads < maxThreads)
00677 {
00678
00679
00680
00681 KResolverThread *th = workers.first();
00682 while (th && th->running())
00683 th = workers.next();
00684
00685 if (th == 0L)
00686
00687 th = new KResolverThread;
00688 else
00689 workers.take();
00690
00691 th->start();
00692 workers.append(th);
00693 runningThreads++;
00694 }
00695
00696 feedWorkers.wakeAll();
00697
00698
00699 workers.first();
00700 while (workers.current())
00701 {
00702 if (!workers.current()->running())
00703 workers.remove();
00704 else
00705 workers.next();
00706 }
00707 }
00708
00709
00710 bool KResolverManager::dequeueNew(KResolver* obj)
00711 {
00712
00713
00714
00715
00716 KResolverPrivate *d = obj->d;
00717
00718
00719 RequestData *curr = newRequests.first();
00720 while (curr)
00721 if (curr->obj == d)
00722 {
00723
00724
00725 d->status = KResolver::Canceled;
00726 d->errorcode = KResolver::Canceled;
00727 d->syserror = 0;
00728 newRequests.take();
00729
00730 delete curr->worker;
00731 delete curr;
00732
00733 return true;
00734 }
00735 else
00736 curr = newRequests.next();
00737
00738
00739 curr = currentRequests.first();
00740 while (curr)
00741 if (curr->obj == d)
00742 {
00743
00744
00745 d->mutex.lock();
00746
00747 d->status = KResolver::Canceled;
00748 d->errorcode = KResolver::Canceled;
00749 d->syserror = 0;
00750
00751
00752 curr->obj = 0L;
00753 curr->input = 0L;
00754 if (curr->worker)
00755 curr->worker->input = 0L;
00756
00757 d->mutex.unlock();
00758 }
00759 else
00760 curr = currentRequests.next();
00761
00762 return false;
00763 }
00764
00765
00766
00767 void KResolverManager::dequeue(KResolver *obj)
00768 {
00769 QMutexLocker locker(&mutex);
00770 dequeueNew(obj);
00771 }
This file is part of the documentation for kdecore Library Version 3.3.90.