← Back to branch summary

~ubuntu-core-dev/synaptic/ubuntu

« back to all changes in this revision

Viewing changes to common/rpackagestatus.cc

  • Committer: Michael Terry
  • Date: 2011-09-26 16:30:35 UTC
  • Revision ID: michael.terry@canonical.com-20110926163035-bck8ol261ksu1gmi
move to lp:ubuntu/synaptic

Show diffs side-by-side

added added

removed removed

Lines of Context:
common/rpackagestatus.cc
1
 
/* rpackagestatus.cc - wrapper for accessing packagestatus information
2
 
 * 
3
 
 * Copyright (c) 2000-2003 Conectiva S/A 
4
 
 *               2002-2008 Michael Vogt <mvo@debian.org>
5
 
 * 
6
 
 * Author: Alfredo K. Kojima <kojima@conectiva.com.br>
7
 
 *         Michael Vogt <mvo@debian.org>
8
 
 * 
9
 
 * Portions Taken from Gnome APT
10
 
 *   Copyright (C) 1998 Havoc Pennington <hp@pobox.com>
11
 
 * 
12
 
 *
13
 
 * This program is free software; you can redistribute it and/or 
14
 
 * modify it under the terms of the GNU General Public License as 
15
 
 * published by the Free Software Foundation; either version 2 of the
16
 
 * License, or (at your option) any later version.
17
 
 *
18
 
 * This program is distributed in the hope that it will be useful,
19
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21
 
 * GNU General Public License for more details.
22
 
 *
23
 
 * You should have received a copy of the GNU General Public License
24
 
 * along with this program; if not, write to the Free Software
25
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
26
 
 * USA
27
 
 */
28
 
 
29
 
#include <apt-pkg/tagfile.h>
30
 
#include <apt-pkg/strutl.h>
31
 
#include "rpackagestatus.h"
32
 
 
33
 
// init the static release array so that we need to
34
 
// run lsb_release only once
35
 
char RPackageStatus::release[255] = {0,};
36
 
 
37
 
// class that finds out what do display to get user
38
 
void RPackageStatus::init()
39
 
{
40
 
   const char *status_short[N_STATUS_COUNT] = {
41
 
      "install", "reinstall", "upgrade", "downgrade", "remove",
42
 
      "purge", "available", "available-locked",
43
 
      "installed-updated", "installed-outdated", "installed-locked",
44
 
      "broken", "new"
45
 
   };
46
 
   memcpy(PackageStatusShortString, status_short, sizeof(status_short));
47
 
 
48
 
   const char *status_long[N_STATUS_COUNT] = {
49
 
      _("Marked for installation"),
50
 
      _("Marked for re-installation"),
51
 
      _("Marked for upgrade"),
52
 
      _("Marked for downgrade"),
53
 
      _("Marked for removal"),
54
 
      _("Marked for complete removal"),
55
 
      _("Not installed"),
56
 
      _("Not installed (locked)"),
57
 
      _("Installed"),
58
 
      _("Installed (upgradable)"),
59
 
      _("Installed (locked to the current version)"),
60
 
      _("Broken"),
61
 
      _("Not installed (new in repository)")
62
 
   };
63
 
   memcpy(PackageStatusLongString, status_long, sizeof(status_long));
64
 
 
65
 
 
66
 
   // check for unsupported stuff
67
 
   if(_config->FindB("Synaptic::mark-unsupported", true)) {
68
 
      string s, labels, origin, components;
69
 
      markUnsupported = true;
70
 
 
71
 
      // read supported labels
72
 
      labels = _config->Find("Synaptic::supported-label", "Debian Debian-Security");
73
 
      stringstream sst1(labels);
74
 
      while(!sst1.eof()) {
75
 
         sst1 >> s;
76
 
         supportedLabels.push_back(s);
77
 
      }
78
 
 
79
 
      // read supported origins
80
 
      origin = _config->Find("Synaptic::supported-origins", "Debian");
81
 
      stringstream sst2(origin);
82
 
      while(!sst2.eof()) {
83
 
         sst2 >> s;
84
 
         supportedOrigins.push_back(s);
85
 
      }
86
 
      
87
 
      // read supported components
88
 
      components = _config->Find("Synaptic::supported-components", "main updates/main");
89
 
      stringstream sst3(components);
90
 
      while(!sst3.eof()) {
91
 
         sst3 >> s;
92
 
         supportedComponents.push_back(s);
93
 
      }
94
 
   } 
95
 
 
96
 
   // init the static release once
97
 
   FILE *fp = popen("lsb_release -c -s","r");
98
 
   if(fp) {
99
 
      fgets((char *)RPackageStatus::release, 255, fp);
100
 
      pclose(fp);
101
 
      _strstrip(release);
102
 
   } 
103
 
}
104
 
 
105
 
bool RPackageStatus::isSupported(RPackage *pkg) 
106
 
{
107
 
   bool res = true;
108
 
 
109
 
   if(markUnsupported) {
110
 
      bool sc, sl, so;
111
 
 
112
 
      sc=sl=so=false;
113
 
 
114
 
      string component = pkg->component();
115
 
      string label = pkg->label();
116
 
      string origin = pkg->origin();
117
 
 
118
 
      for(unsigned int i=0;i<supportedComponents.size();i++) {
119
 
         if(supportedComponents[i] == component) {
120
 
            sc = true;
121
 
            break;
122
 
         }
123
 
      }
124
 
      for(unsigned int i=0;i<supportedLabels.size();i++) {
125
 
         if(supportedLabels[i] == label) {
126
 
            sl = true;
127
 
            break;
128
 
         }
129
 
      }
130
 
      for(unsigned int i=0;i<supportedOrigins.size();i++) {
131
 
         if(supportedOrigins[i] == origin) {
132
 
            so = true;
133
 
            break;
134
 
         }
135
 
      }
136
 
 
137
 
      res = (sc & sl & so & pkg->isTrusted());
138
 
   }
139
 
 
140
 
   return res;
141
 
}
142
 
 
143
 
int RPackageStatus::getStatus(RPackage *pkg)
144
 
{
145
 
   int flags = pkg->getFlags();
146
 
   int ret = NotInstalled;
147
 
 
148
 
   if (pkg->wouldBreak()) {
149
 
      ret = IsBroken;
150
 
   } else if (flags & RPackage::FNewInstall) {
151
 
      ret = ToInstall;
152
 
   } else if (flags & RPackage::FUpgrade) {
153
 
      ret = ToUpgrade;
154
 
   } else if (flags & RPackage::FReInstall) {
155
 
      ret = ToReInstall;
156
 
   } else if (flags & RPackage::FDowngrade) {
157
 
      ret = ToDowngrade;
158
 
   } else if (flags & RPackage::FPurge) {
159
 
      ret = ToPurge;
160
 
   } else if (flags & RPackage::FRemove) {
161
 
      ret = ToRemove;
162
 
   } else if (flags & RPackage::FInstalled) {
163
 
      if (flags & RPackage::FPinned)
164
 
         ret = InstalledLocked;
165
 
      else if (flags & RPackage::FOutdated)
166
 
         ret = InstalledOutdated;
167
 
      else
168
 
         ret = InstalledUpdated;
169
 
   } else {
170
 
      if (flags & RPackage::FPinned)
171
 
         ret = NotInstalledLocked;
172
 
      else if (flags & RPackage::FNew)
173
 
         ret = IsNew;
174
 
      else
175
 
         ret = NotInstalled;
176
 
   }
177
 
 
178
 
   return ret;
179
 
}
180
 
 
181
 
bool RPackageStatus::maintenanceEndTime(RPackage *pkg, struct tm *res) 
182
 
{
183
 
   //cerr << "RPackageStatus::maintenanceEndTime()" << std::endl;
184
 
 
185
 
   pkgTagSection sec;
186
 
   time_t release_date = -1;
187
 
 
188
 
   string distro = _config->Find("Synaptic::supported-label");
189
 
   string releaseFile = pkg->getReleaseFileForOrigin(distro, release);
190
 
   if(!FileExists(releaseFile)) {
191
 
      // happens e.g. when there is no release file and is harmless
192
 
      //cerr << "mainenanceEndTime(): can not find file: " << releaseFile << endl;
193
 
      return false;
194
 
   }
195
 
   
196
 
   // read the relase file
197
 
   FileFd fd(releaseFile, FileFd::ReadOnly);
198
 
   pkgTagFile t(&fd);
199
 
   t.Step(sec);
200
 
 
201
 
   // get the time_t form the string
202
 
   if(!StrToTime(sec.FindS("Date"), release_date))
203
 
      return false;
204
 
 
205
 
   // if its not a supported package, return 0 
206
 
   if(!isSupported(pkg))
207
 
      return false;
208
 
 
209
 
   // now calculate the time until there is support
210
 
   gmtime_r(&release_date, res);
211
 
   
212
 
   const int support_time =_config->FindI("Synaptic::supported-month", 0);
213
 
   if (support_time <= 0)
214
 
      return false;
215
 
 
216
 
   res->tm_year += (support_time / 12) + ((res->tm_mon + support_time % 12) / 12);
217
 
   res->tm_mon = (res->tm_mon + support_time) % 12;
218
 
 
219
 
   return true;
220
 
}