summaryrefslogtreecommitdiff
path: root/find-deprecated-pkgs
blob: 24c63b37175cabe659e1ea9b50cd8c3c03a8a9d9 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
#!/bin/bash
# Copyright (C) 2018 David P. <megver83@parabola.nu>
# Find deprecated Arch packages that are still in our blacklists.

# Repositories for specific arch'es.
# Common repos are in 'repos' variable.
repos="core community extra"
repos_x86_64="$repos testing multilib multilib-testing"
repos_i686="$repos testing build-support"
repos_armv7h="$repos alarm" # although we don't sync [alarm] we blacklist its packages to conflict with your-freedom

# Parabola repos for checking blacklists like your-privacy,
# which sometimes block [libre] and [pcr] packages.
# [nonprism] and [nonsystemd] are not listened because
# we do not blacklists those packages anywhere
repos_parabola="pcr pcr-multilib pcr-multilib-testing pcr-testing libre libre-multilib libre-multilib-testing libre-testing"

# Set the blacklist files. The packages here always have a [libre] replacement if there's one.
# aur-blacklist.txt is not here since we want to check Arch's official repos
blacklists="blacklist.txt"

# List here files that may also blacklist Parabola packages.
# These are intended to be used with $repos_parabola
blacklists_parabola="your-initfreedom-blacklist.txt your-privacy-blacklist.txt your-freedom_emu-blacklist.txt"

# Mirrors. Please choose HTTPS over HTTP when possible
# x86_64 mirrors
for r in $repos_x86_64; do
  mirrors+=(https://mirrors.edge.kernel.org/archlinux/$r/os/x86_64/)
done
# i686 mirrors
for r in $repos_i686; do
  mirrors+=(https://mirror.archlinux32.org/i686/$r/)
done
# armv7h mirrors
for r in $repos_armv7h; do
  mirrors+=(https://fl.us.mirror.archlinuxarm.org/armv7h/$r/)
done

add_parabola_mirrors(){
  # Parabola mirrors, used to check [libre] and [pcr] packages
  for r in $repos_parabola; do
    mirrors+=(https://mirror.grapentin.org/parabola/$r/os/x86_64/)
    mirrors+=(https://mirror.grapentin.org/parabola/$r/os/i686/)
    mirrors+=(https://mirror.grapentin.org/parabola/$r/os/armv7h/)
  done
}

# Sed expresion tested for Nginx, change if needed
sedexp='s/.*href="//;s/\.pkg.tar.xz.*//'
# extra sedexps for special characters/symbols
sedexp+=';s/%2B/+/g;s/%3A/:/g;s/%40/@/g'

usage(){
cat <<EOM
Usage: ${0##*/} [arch|parabola]
Check if there are inexistent packages in the blacklists.

Arguments:
  arch                        Compares ArchLinux{32,ARM} blacklists
                              with their repositories
  parabola                    Compares Arch/Parabola blacklists (e.g.
                              your-privacy) with Parabola's and Arch's
                              repos

The 'parabola' argument compares with our repositories and Arch's
since in blacklists like your-privacy and your-initfreedom we also block
some packages from [pcr] (like jitsi) and [libre] (like icedove), and
probably also from their -multilib, -testing and -multilib-testing derivatives.

Note that the package architecture is always specified with 'parabola', and
in 'arch' only when there's an uneeded replacement. This is because your-freedom
is for any architecture and no matter if you use Parabola x86_64 or i686, it
will always conflict packages that are even for armv7h only (and vice versa).

To easily remove a line, you can use the following sed expresion:

  sed '/^pkgname:/d' -i blacklist_file.txt
EOM
}

mkpkglist(){
  parabola_pkgs=$(mktemp)
  arch_pkgs=$(mktemp)
  case $1 in
        parabola) add_parabola_mirrors
                  curl -s ${mirrors[@]} | grep '".*.pkg.tar.xz"' | sed $sedexp > $parabola_pkgs

                  # Separate packages by architecture
                  for arch in x86_64 i686 armv7h any; do
                    grep $arch$ $parabola_pkgs | for f in $(</dev/stdin); do
                        echo "${f%-*-*-*} $arch" >> $parabola_pkgs-$arch
                    done
                  done
                  cat $parabola_pkgs-{x86_64,i686,armv7h,any} | sort -u > $parabola_pkgs
                  rm $parabola_pkgs-{x86_64,i686,armv7h,any}
        ;;
        arch) curl -s ${mirrors[@]} | grep '".*.pkg.tar.xz"' | sed $sedexp > $arch_pkgs

              # Separate packages by architecture
              for arch in x86_64 i686 armv7h any; do
                grep $arch$ $arch_pkgs | for f in $(</dev/stdin); do
                    echo "${f%-*-*-*} $arch" >> $arch_pkgs-$arch
                done
              done
              cat $arch_pkgs-{x86_64,i686,armv7h,any} | sort -u > $arch_pkgs
              rm $arch_pkgs-{x86_64,i686,armv7h,any}
        ;;
  esac
}

err(){
  printf '%s==> Error:%s %s\n' \
         "$(tput bold;tput setaf 1)" \
         "$(tput sgr0)" \
         "$1"
  exit 1
}

msg(){
  printf '%s==>%s %s\n' \
         "$(tput bold;tput setaf 2)" \
         "$(tput sgr0)" \
         "$1"
}

submsg(){
  printf '  %s->%s %s\n' \
         "$(tput bold;tput setaf 4)" \
         "$(tput sgr0)" \
         "$1"
}

get_libre_pkgs(){
  # We'll use this when we check Arch's pkgs only
  if ! [[ -e $libre_pkgs ]]; then
  libre_pkgs=$(mktemp)
  for r in libre libre-multilib libre-testing libre-multilib-testing; do
    mirrors_parabola+=(https://mirror.grapentin.org/parabola/$r/os/x86_64/)
    mirrors_parabola+=(https://mirror.grapentin.org/parabola/$r/os/i686/)
    mirrors_parabola+=(https://mirror.grapentin.org/parabola/$r/os/armv7h/)
  done
  curl -s ${mirrors_parabola[@]} | grep '".*.pkg.tar.xz"' | sed $sedexp > $libre_pkgs
  for arch in x86_64 i686 armv7h any; do
    grep $arch$ $libre_pkgs | for f in $(</dev/stdin); do
      echo "${f%-*-*-*} $arch" >> $libre_pkgs-$arch
    done
  done
  cat $libre_pkgs-{x86_64,i686,armv7h,any} | sort -u > $libre_pkgs
  fi
}

add(){
  list=$(( $list + 1 ))
}

compare_pkgs(){
  # $1 is the pkgname and replacement (used when checking Arch pkgs)
  # $2 is the packages file list

  # First check if the pkg is available for
  # a specific architecture, if not, check
  # if it's for 'any'
  package="${1%%:*}"
  replacement="$(cut -d ":" -f2 <(echo $1))"

  for arch in x86_64 i686 armv7h; do
    grep $arch$ $2 | awk '{print $1}' | grep -xw ^$package &> /dev/null || \
    grep any$ $2 | awk '{print $1}' | grep -xw ^$package &> /dev/null || \
    if [ $2 = $arch_pkgs ]; then
      get_libre_pkgs
      # Check if the package has a replacement, and
      # if such replacement is available for the same
      # architectures
      if ! [[ $replacement = "" ]]; then
        # If this works, it means the pkg doesn't exist for $arch in Arch,
        # but we have the [libre] replacement which should be deprecated.
        grep $arch$ $libre_pkgs | awk '{print $1}' | grep -xw ^$replacement &> /dev/null || \
        grep any$ $libre_pkgs | awk '{print $1}' | grep -xw ^$replacement &> /dev/null

        case $? in
            0) to_be_removed+=($arch)
            ;;
            *) is_not_for+=($arch)
            ;;
        esac
      else
        # However if this fails, it means the pkg doesn't have a replacement
        # for $arch, or it simply doesn't have a replacement.
        is_not_for+=($arch)
      fi
    elif [ $2 = $parabola_pkgs ]; then
      if ! [[ $replacement = "" ]]; then
        # Look for the replacement
        grep $arch$ $parabola_pkgs | awk '{print $1}' | grep -xw ^$replacement &> /dev/null || \
        grep any$ $parabola_pkgs | awk '{print $1}' | grep -xw ^$replacement &> /dev/null

        case $? in
            0) to_be_deleted+=($arch)
            ;;
            *) isnt_for+=($arch)
            ;;
        esac
      else
        isnt_for+=($arch)
      fi
    fi
  done

  # Arch
  if [[ ${is_not_for[@]} = "x86_64 i686 armv7h" ]]; then
    submsg "$package was not found"
    add
  elif [[ ${to_be_removed[@]} = "x86_64 i686 armv7h" ]]; then
    submsg "$package was not found, but we've [libre] replacements which should be removed"
    add
  elif ! [[ ${is_not_for[@]} = "" ]] || ! [[ ${to_be_removed[@]} = "" ]]; then
    for arch in ${to_be_removed[@]}; do
      # If the replacement is available for the three arch'es supported
      # by Parabola, then shut up
      for a in x86_64 i686 armv7h; do
        grep -xw "^$replacement $a$" $libre_pkgs &> /dev/null && arches+=($a)
      done
      if ! [[ ${arches[*]} = "x86_64 i686 armv7h" ]]; then
        submsg "$package ($arch) was not found, but we've a [libre] replacement which should be removed"
        add
      fi
      unset arches
    done
  fi

  # Parabola
  if [[ ${isnt_for[@]} = "x86_64 i686 armv7h" ]]; then
    submsg "$package was not found"
    add
  elif ! [[ ${isnt_for[@]} = "" ]]; then
    for arch in ${to_be_deleted[@]}; do
      submsg "$package ($arch) was not found, but we've $replacement as replacement and should be removed"
      add
    done
  fi

  # Unset the variables so they can be re-used
  unset to_be_deleted to_be_removed is_not_for isnt_for arch package replacement
}

check(){
  mkpkglist $1
  case $1 in
        parabola) msg 'Comparing blacklists with Parabola packages ...'
                  pkgs=$(for bl in $blacklists_parabola; do grep -v ^# $bl | awk '{print $1}'; done)
                  for p in $pkgs; do
                    compare_pkgs $p $parabola_pkgs
                  done
                  rm -f $parabola_pkgs
        ;;
        arch) msg 'Comparing blacklists with Arch packages ...'
              pkgs=$(for bl in $blacklists; do grep -v ^# $bl | awk '{print $1}'; done)
              for p in $pkgs; do
                compare_pkgs $p $arch_pkgs
              done
              rm -f $arch_pkgs $libre_pkgs
        ;;
        *) err "$1 is not a valid argument"
        ;;
  esac
  if ! [[ $list -gt 0 ]]; then
    submsg 'No packages to show'
  fi
  msg 'done'
}

if [[ $@ = "" ]]; then
  usage
else
  ip r | grep ^default | awk '{print $3}' |
  ping -q -w1 -c1 $(tail -n1 /dev/stdin) &> /dev/null || err 'You must have internet connection to run this program'
  for arg in $@; do check $arg; done
fi