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