bool is_path_media_or_fm_no_call_no_record()
{
DECLARE_WM8994(codec);
if ((is_path(HEADPHONES)
&& (wm8994->codec_state & PLAYBACK_ACTIVE)
&& (wm8994->stream_state & PCM_STREAM_PLAYBACK)
&& !(wm8994->codec_state & CALL_ACTIVE)
&& (wm8994->rec_path == MIC_OFF)
) || is_path(RADIO_HEADPHONES))
return true;
return false;
}
void delete_cmd(int argc, char **args, int call_type) {
char *path;
switch (call_type) {
case CALL_TYPE_HELP:
puts("DELETE ITEMS\n");
return;
case CALL_TYPE_DESC:
puts("[PATH] [PATH] [PATH] . . .\n");
puts("\tPATH\tTHE PATH OF THE TARGET TO DELETE\n");
return;
}
while (argc--) {
path = get_full_path(*args);
if (is_path(path, strlen(path), TYPE_UNDEFINED, 0)) {
delete(path, strlen(path));
} else {
puts(*args);
puts(" not found!\n");
}
args++;
free(path);
}
}
void update_hpvol()
{
unsigned short val;
DECLARE_WM8994(codec);
// don't affect headphone amplifier volume
// when not on heapdhones or if call is active
if (!is_path(HEADPHONES)
|| (wm8994->codec_state & CALL_ACTIVE))
return;
bypass_write_hook = true;
// we don't need the Volume Update flag when sending the first volume
val = (WM8994_HPOUT1L_MUTE_N | hplvol);
val |= WM8994_HPOUT1L_ZC;
wm8994_write(codec, WM8994_LEFT_OUTPUT_VOLUME, val);
// this time we write the right volume plus the Volume Update flag.
//This way, both volume are set at the same time
val = (WM8994_HPOUT1_VU | WM8994_HPOUT1R_MUTE_N | hprvol);
val |= WM8994_HPOUT1L_ZC;
wm8994_write(codec, WM8994_RIGHT_OUTPUT_VOLUME, val);
bypass_write_hook = false;
}
void omg(t_list *list, int value, int ant)
{
t_list *link;
t_salle *path;
t_list *start;
value = 1;
link = list;
start = list;
is_possible(list);
if (preliminary_check(list) == 1)
fast_end(list, ant);
while (((t_salle *)link->content)->status != END)
link = link->next;
path = CNT;
while (path_avaiable(link) >= 1)
{
while (path && path->status != START)
path = is_path(path, value);
reinit_dist(start);
give_value((t_salle*)start->content);
((t_salle *)list->content)->dist = 0;
value++;
path = ((t_salle *)link->content);
}
print(list, how_many_valid(list), ant);
}
void main(){
is_path(0,0)?printf("Yes"):printf("No");
}
static int parse_fstab(void) {
FILE *f;
int r = 0;
struct mntent *me;
errno = 0;
f = setmntent("/etc/fstab", "r");
if (!f) {
if (errno == ENOENT)
return 0;
log_error("Failed to open /etc/fstab: %m");
return -errno;
}
while ((me = getmntent(f))) {
char _cleanup_free_ *where = NULL, *what = NULL;
int k;
what = fstab_node_to_udev_node(me->mnt_fsname);
where = strdup(me->mnt_dir);
if (!what || !where) {
r = log_oom();
goto finish;
}
if (is_path(where))
path_kill_slashes(where);
log_debug("Found entry what=%s where=%s type=%s", what, where, me->mnt_type);
if (streq(me->mnt_type, "swap"))
k = add_swap(what, me);
else {
bool noauto, nofail, automount, isbind, isnetwork;
noauto = !!hasmntopt(me, "noauto");
nofail = !!hasmntopt(me, "nofail");
automount =
hasmntopt(me, "comment=systemd.automount") ||
hasmntopt(me, "x-systemd.automount");
isbind = mount_is_bind(me);
isnetwork = mount_is_network(me);
k = add_mount(what, where, me->mnt_type, me->mnt_opts,
me->mnt_passno, false, noauto, nofail,
automount, isbind, isnetwork,
"/etc/fstab");
}
if (k < 0)
r = k;
}
finish:
endmntent(f);
return r;
}
//Generates solution matrix (returns true if path is possible)
int is_path(int i,int j){
int p,q;
printf("%d-%d\n",i,j);
if(i==m-1 && j==n-1)
return 1;
if(!is_open(i,j)) return 0;
p=is_open(i+1,j);
q=is_open(i,j+1);
a[i][j]=(p && is_path(i+1,j)) || (q && is_path(i,j+1));
if(!p && !q){
a[i][j]=0;
return 0;
}
}
int assertion(abstract_heapt *heap) {
abstract_heapt t1;
if (is_null(heap, y)) {
return 0;
}
abstract_update(heap, &t1, y, x);
return is_path(&t1, x, null_ptr);
}
static int parse_fstab(void) {
FILE *f;
int r = 0;
struct mntent *me;
errno = 0;
f = setmntent("/etc/fstab", "r");
if (!f) {
if (errno == ENOENT)
return 0;
log_error("Failed to open /etc/fstab: %m");
return -errno;
}
while ((me = getmntent(f))) {
char *where, *what;
int k;
what = fstab_node_to_udev_node(me->mnt_fsname);
if (!what) {
r = log_oom();
goto finish;
}
where = strdup(me->mnt_dir);
if (!where) {
r = log_oom();
free(what);
goto finish;
}
if (is_path(where))
path_kill_slashes(where);
log_debug("Found entry what=%s where=%s type=%s", what, where, me->mnt_type);
if (streq(me->mnt_type, "swap"))
k = add_swap(what, me);
else
k = add_mount(what, where, me);
free(what);
free(where);
if (k < 0)
r = k;
}
finish:
endmntent(f);
return r;
}
void read_cmd(int argc, char **args, int call_type) {
char *path;
File *f;
char *buff;
uint32_t i;
uint32_t len;
switch (call_type) {
case CALL_TYPE_HELP:
puts("READ A FILE\n");
return;
case CALL_TYPE_DESC:
puts("PATH\n");
puts("\tPATH\tTHE PATH OF THE FILE TO READ\n");
return;
}
f = 0;
while (argc--) {
path = get_full_path(*args);
if (is_path(path, strlen(path), TYPE_FILE, 0)) {
f = open(path, strlen(path), 'r');
break;
}
free(path);
}
if (!f) {
puts("Path not found!\n");
return;
}
clear_screen();
buff = (char *) palloc();
while ((len = read_from_file(f, 4096, buff))) {
f->r_seek += len;
for (i = 0; i < len; i++) {
if (get_current() / 80 >= 21) {
set_color(RED, BLACK);
puts("\nPRESS ANY KEY TO CONTINUE");
set_color(LIGHT_GRAY, BLACK);
getc();
clear_screen();
}
putc(*(buff + i));
}
}
free((void *) f);
pfree((void *) buff);
putc('\n');
}
static char *resolve_fragment(const char *fragment, const char **search_paths) {
const char **p;
char *resolved_path;
if (is_path(fragment))
return strdup(fragment);
STRV_FOREACH(p, search_paths) {
resolved_path = strjoin(*p, "/", fragment, NULL);
if (resolved_path == NULL) {
log_error("Out of memory");
return NULL;
}
if (access(resolved_path, F_OK) == 0)
return resolved_path;
free(resolved_path);
}
static void print_path( fastpathfinder::map & m, fastpathfinder::pathfinder<> & pf, size_t _bx, size_t _by, size_t _ex, size_t _ey )
{
for( size_t j = _by; j != _ey; ++j )
{
for( size_t i = _bx; i != _ex; ++i )
{
uint8_t mask;
if( m.getCellMask( i, j, mask ) == false )
{
continue;
}
//const fastpathfinder::point_array & path = pf.getPath();
const fastpathfinder::point_array & path_filter = pf.getPathFilter();
if( mask > 0 )
{
printf("#");
}
else if( is_path( path_filter, i, j ) == true )
{
printf("o");
}
else
{
fastpathfinder::point p(i, j);
fastpathfinder::pathfinder_cell * c = pf.getCell( p );
printf("*");
}
}
printf("\n");
}
}
void change_dir_cmd(int argc, char **args, int call_type) {
char *path;
switch (call_type) {
case CALL_TYPE_HELP:
puts("CHANGE THE WORKING DIRECTORY\n");
return;
case CALL_TYPE_DESC:
puts("PATH\n");
puts("\tPATH\tTHE PATH OF THE NEW WORKING DIRECTORY\n");
return;
}
if (argc >= 1) {
path = get_full_path(*args);
if (strlen(path) == 1 || is_path(path, strlen(path), TYPE_DIR, 0)) {
free((void *) working_dir);
working_dir = path;
return;
}
free(path);
}
puts("Path not found!\n");
}
int mac_selinux_unit_access_check_strv(char **units,
sd_bus_message *message,
Manager *m,
const char *permission,
sd_bus_error *error) {
#ifdef HAVE_SELINUX
char **i;
Unit *u;
int r;
STRV_FOREACH(i, units) {
if (is_path(*i))
r = manager_load_unit(m, NULL, *i, error, &u);
else
r = manager_load_unit(m, *i, NULL, error, &u);
if (r < 0)
return r;
r = mac_selinux_unit_access_check(u, message, permission, error);
if (r < 0)
return r;
}
#endif
return 0;
}
void update_speaker_tuning(bool with_mute)
{
DECLARE_WM8994(codec);
if (!(is_path(SPEAKER) || (wm8994->codec_state & CALL_ACTIVE)))
return;
printk("We are on speaker!\n");
if (speaker_tuning) {
// DRC settings
wm8994_write(codec, WM8994_AIF1_DRC1_3, 0x0010);
wm8994_write(codec, WM8994_AIF1_DRC1_4, 0x00EB);
// hardware EQ
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_GAINS_1, 0x041D);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_GAINS_2, 0x4C00);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_1_A, 0x0FE3);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_1_B, 0x0403);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_1_PG, 0x0074);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_2_A, 0x1F03);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_2_B, 0xF0F9);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_2_C, 0x040A);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_2_PG, 0x03DA);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_3_A, 0x1ED2);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_3_B, 0xF11A);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_3_C, 0x040A);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_3_PG, 0x045D);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_4_A, 0x0E76);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_4_B, 0xFCE4);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_4_C, 0x040A);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_4_PG, 0x330D);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_5_A, 0xFC8F);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_5_B, 0x0400);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_5_PG, 0x323C);
// Speaker Boost tuning
wm8994_write(codec, WM8994_CLASSD, 0x0170);
} else {
// DRC settings
wm8994_write(codec, WM8994_AIF1_DRC1_3, 0x0028);
wm8994_write(codec, WM8994_AIF1_DRC1_4, 0x0186);
// hardware EQ
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_GAINS_1, 0x0019);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_GAINS_2, 0x6280);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_1_A, 0x0FC3);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_1_B, 0x03FD);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_1_PG, 0x00F4);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_2_A, 0x1F30);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_2_B, 0xF0CD);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_2_C, 0x040A);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_2_PG, 0x032C);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_3_A, 0x1C52);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_3_B, 0xF379);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_3_C, 0x040A);
wm8994_write(codec, WM8994_AIF1_DAC1_EQ_BAND_3_PG, 0x0DC1);
wm8994_write(codec, WM8994_CLASSD, 0x0170);
// Speaker Boost tuning
wm8994_write(codec, WM8994_CLASSD, 0x0168);
}
}
void update_recording_preset(bool with_mute)
{
if (!is_path(MAIN_MICROPHONE))
return;
switch (recording_preset) {
case 0:
// Original:
// On Galaxy S: IN1L_VOL1=11000 (+19.5 dB)
// On Nexus S: variable value
wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME,
WM8994_IN1L_VU | origin_recgain);
wm8994_write(codec, WM8994_INPUT_MIXER_3, origin_recgain_mixer);
// DRC disabled
wm8994_write(codec, WM8994_AIF1_DRC1_1, 0x0080);
break;
case 2:
// High sensitivy:
// Original - 4.5 dB, IN1L_VOL1=10101 (+15 dB)
wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME, 0x0115);
wm8994_write(codec, WM8994_INPUT_MIXER_3, 0x30);
// DRC Input: -6dB, Ouptut -3.75dB
// Above knee 1/8, Below knee 1/2
// Max gain 24 / Min gain -12
wm8994_write(codec, WM8994_AIF1_DRC1_1, 0x009A);
wm8994_write(codec, WM8994_AIF1_DRC1_2, 0x0426);
wm8994_write(codec, WM8994_AIF1_DRC1_3, 0x0019);
wm8994_write(codec, WM8994_AIF1_DRC1_4, 0x0105);
break;
case 3:
// Concert new: IN1L_VOL1=10110 (+4.5 dB)
// +30dB input mixer gain deactivated
wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME, 0x010F);
wm8994_write(codec, WM8994_INPUT_MIXER_3, 0x20);
// DRC Input: -4.5dB, Ouptut -6.75dB
// Above knee 1/4, Below knee 1/2
// Max gain 24 / Min gain -12
wm8994_write(codec, WM8994_AIF1_DRC1_1, 0x009A);
wm8994_write(codec, WM8994_AIF1_DRC1_2, 0x0846);
wm8994_write(codec, WM8994_AIF1_DRC1_3, 0x0011);
wm8994_write(codec, WM8994_AIF1_DRC1_4, 0x00C9);
break;
case 4:
// ULTRA LOUD:
// Original - 36 dB - 30 dB IN1L_VOL1=00000 (-16.5 dB)
// +30dB input mixer gain deactivated
wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME, 0x0100);
wm8994_write(codec, WM8994_INPUT_MIXER_3, 0x20);
// DRC Input: -7.5dB, Ouptut -6dB
// Above knee 1/8, Below knee 1/4
// Max gain 36 / Min gain -12
wm8994_write(codec, WM8994_AIF1_DRC1_1, 0x009A);
wm8994_write(codec, WM8994_AIF1_DRC1_2, 0x0847);
wm8994_write(codec, WM8994_AIF1_DRC1_3, 0x001A);
wm8994_write(codec, WM8994_AIF1_DRC1_4, 0x00C9);
break;
default:
// make sure recording_preset is the default
recording_preset = 1;
// New Balanced: Original - 16.5 dB
// IN1L_VOL1=01101 (+27 dB)
// +30dB input mixer gain deactivated
wm8994_write(codec, WM8994_LEFT_LINE_INPUT_1_2_VOLUME, 0x055D);
wm8994_write(codec, WM8994_INPUT_MIXER_3, 0x20);
// DRC Input: -18.5dB, Ouptut -9dB
// Above knee 1/8, Below knee 1/2
// Max gain 18 / Min gain -12
wm8994_write(codec, WM8994_AIF1_DRC1_1, 0x009A);
wm8994_write(codec, WM8994_AIF1_DRC1_2, 0x0845);
wm8994_write(codec, WM8994_AIF1_DRC1_3, 0x0019);
wm8994_write(codec, WM8994_AIF1_DRC1_4, 0x030C);
break;
}
}
/*===========================================
* filepath -- Find file in sequence of paths
* handles NULL in either argument
* returns alloc'd buffer
* Warning: if called with mode other than "r" this may not
* do what you want, because 1) if file is not found, it appends ext.
* and 2) file always goes in 1st specified directory of path unless
* name is absolute or ./something
*=========================================*/
STRING
filepath (CNSTRING name, CNSTRING mode, CNSTRING path, CNSTRING ext, INT utf8)
{
char buf1[MAXPATHLEN], buf2[MAXPATHLEN];
STRING p, q;
INT nlen, elen;
if (ISNULL(name)) return NULL;
if (ISNULL(path)) return strsave(name);
nlen = strlen(name);
if (ext && *ext) {
elen = strlen(ext);
if ((nlen > elen) && path_match(name+nlen-elen, ext)) {
ext = NULL;
elen = 0;
}
}
else { ext = NULL; elen = 0; }
/* at this point ext is non-null only if name doesn't
* end in ext. I.E. we need to check for name + ext and name
*/
if (nlen + strlen(path) + elen >= MAXLINELEN) return NULL;
/* for absolute and relative path names we first check the
* pathname for validity relative to the current directory
*/
if (is_path(name)) {
/* If this is a path, i.e. it has multiple path elements
* use the name as is first. So absolute paths don't
* get resolved by appending search paths.
*/
if (ext) {
strcpy(buf1,name);
nlen = strlen(buf1);
strcat(buf1, ext);
if (access(buf1, 0) == 0) return strsave(buf1);
buf1[nlen] = '\0'; /* remove extension */
if (access(buf1, 0) == 0) return strsave(buf1);
}
if (access(name, 0) == 0) return strsave(name);
/* fail if get here and name begins with a / or ./
* as we didn't find the file.
* however let foo/bar sneak thru, so we allow access
* to files in subdirectories of the search path if
* named in the filename.
*/
if (is_dir_sep(name[0]) || (name[0] == '.' && is_dir_sep(name[1])))
return strsave(name);
#ifdef WIN32
if (name[0] && name[1]==':' && isasciiletter(name[0])) {
return strsave(name);
}
#endif
}
/* it is a relative path, so search for it in search path */
strcpy(buf1, path);
zero_separate_path(buf1);
p = buf1;
while (*p) {
q = buf2;
strcpy(q, p);
expand_special_fname_chars(buf2, sizeof(buf2), utf8);
q += strlen(q);
if (q>buf2 && !is_dir_sep(q[-1])) {
strcpy(q, LLSTRDIRSEPARATOR);
q++;
}
strcpy(q, name);
if (ext) {
nlen = strlen(buf2);
strcat(buf2, ext);
if (access(buf2, 0) == 0) return strsave(buf2);
buf2[nlen] = '\0'; /* remove extension */
}
if (access(buf2, 0) == 0) return strsave(buf2);
p += strlen(p);
p++;
}
if (mode[0] == 'r') return NULL;
p = buf1;
q = buf2;
strcpy(q, p);
expand_special_fname_chars(buf2, sizeof(buf2), utf8);
q += strlen(q);
if (q>buf2 && !is_dir_sep(q[-1])) {
strcpy(q, LLSTRDIRSEPARATOR);
q++;
}
strcpy(q, name);
if (ext) strcat(q, ext);
return strsave(buf2);
}
static int add_mount(const char *what, const char *where, struct mntent *me) {
char *name = NULL, *unit = NULL, *lnk = NULL, *device = NULL, *automount_name = NULL, *automount_unit = NULL;
FILE *f = NULL;
bool noauto, nofail, automount, isbind, isnetwork;
int r;
const char *post, *pre;
assert(what);
assert(where);
assert(me);
if (streq(me->mnt_type, "autofs"))
return 0;
if (!is_path(where)) {
log_warning("Mount point %s is not a valid path, ignoring.", where);
return 0;
}
if (mount_point_is_api(where) ||
mount_point_ignore(where))
return 0;
isnetwork = mount_is_network(me);
isbind = mount_is_bind(me);
noauto = !!hasmntopt(me, "noauto");
nofail = !!hasmntopt(me, "nofail");
automount =
hasmntopt(me, "comment=systemd.automount") ||
hasmntopt(me, "x-systemd.automount");
if (isnetwork) {
post = SPECIAL_REMOTE_FS_TARGET;
pre = SPECIAL_REMOTE_FS_PRE_TARGET;
} else {
post = SPECIAL_LOCAL_FS_TARGET;
pre = SPECIAL_LOCAL_FS_PRE_TARGET;
}
name = unit_name_from_path(where, ".mount");
if (!name) {
r = log_oom();
goto finish;
}
unit = strjoin(arg_dest, "/", name, NULL);
if (!unit) {
r = log_oom();
goto finish;
}
f = fopen(unit, "wxe");
if (!f) {
r = -errno;
log_error("Failed to create unit file: %m");
goto finish;
}
fputs("# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=/etc/fstab\n"
"DefaultDependencies=no\n", f);
if (!path_equal(where, "/"))
fprintf(f,
"After=%s\n"
"Wants=%s\n"
"Conflicts=" SPECIAL_UMOUNT_TARGET "\n"
"Before=" SPECIAL_UMOUNT_TARGET "\n",
pre,
pre);
if (!noauto && !nofail && !automount)
fprintf(f,
"Before=%s\n",
post);
fprintf(f,
"\n"
"[Mount]\n"
"What=%s\n"
"Where=%s\n"
"Type=%s\n"
"FsckPassNo=%i\n",
what,
where,
me->mnt_type,
me->mnt_passno);
if (!isempty(me->mnt_opts) &&
!streq(me->mnt_opts, "defaults"))
fprintf(f,
"Options=%s\n",
me->mnt_opts);
fflush(f);
if (ferror(f)) {
log_error("Failed to write unit file: %m");
r = -errno;
goto finish;
}
if (!noauto) {
lnk = strjoin(arg_dest, "/", post, nofail || automount ? ".wants/" : ".requires/", name, NULL);
if (!lnk) {
r = log_oom();
goto finish;
}
mkdir_parents_label(lnk, 0755);
if (symlink(unit, lnk) < 0) {
log_error("Failed to create symlink: %m");
r = -errno;
goto finish;
}
if (!isbind &&
!path_equal(where, "/")) {
r = device_name(what, &device);
if (r < 0)
goto finish;
if (r > 0) {
free(lnk);
lnk = strjoin(arg_dest, "/", device, ".wants/", name, NULL);
if (!lnk) {
r = log_oom();
goto finish;
}
mkdir_parents_label(lnk, 0755);
if (symlink(unit, lnk) < 0) {
log_error("Failed to create symlink: %m");
r = -errno;
goto finish;
}
}
}
}
if (automount && !path_equal(where, "/")) {
automount_name = unit_name_from_path(where, ".automount");
if (!name) {
r = log_oom();
goto finish;
}
automount_unit = strjoin(arg_dest, "/", automount_name, NULL);
if (!automount_unit) {
r = log_oom();
goto finish;
}
fclose(f);
f = fopen(automount_unit, "wxe");
if (!f) {
r = -errno;
log_error("Failed to create unit file: %m");
goto finish;
}
fprintf(f,
"# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=/etc/fstab\n"
"DefaultDependencies=no\n"
"Conflicts=" SPECIAL_UMOUNT_TARGET "\n"
"Before=" SPECIAL_UMOUNT_TARGET " %s\n"
"\n"
"[Automount]\n"
"Where=%s\n",
post,
where);
fflush(f);
if (ferror(f)) {
log_error("Failed to write unit file: %m");
r = -errno;
goto finish;
}
free(lnk);
lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", automount_name, NULL);
if (!lnk) {
r = log_oom();
goto finish;
}
mkdir_parents_label(lnk, 0755);
if (symlink(automount_unit, lnk) < 0) {
log_error("Failed to create symlink: %m");
r = -errno;
goto finish;
}
}
r = 0;
finish:
if (f)
fclose(f);
free(unit);
free(lnk);
free(name);
free(device);
free(automount_name);
free(automount_unit);
return r;
}
static int add_mount(
const char *what,
const char *where,
const char *type,
const char *opts,
int passno,
bool noauto,
bool nofail,
bool automount,
const char *post,
const char *source) {
_cleanup_free_ char
*name = NULL, *unit = NULL, *lnk = NULL,
*automount_name = NULL, *automount_unit = NULL;
_cleanup_fclose_ FILE *f = NULL;
assert(what);
assert(where);
assert(type);
assert(opts);
assert(source);
if (streq(type, "autofs"))
return 0;
if (!is_path(where)) {
log_warning("Mount point %s is not a valid path, ignoring.", where);
return 0;
}
if (mount_point_is_api(where) ||
mount_point_ignore(where))
return 0;
name = unit_name_from_path(where, ".mount");
if (!name)
return log_oom();
unit = strjoin(arg_dest, "/", name, NULL);
if (!unit)
return log_oom();
f = fopen(unit, "wxe");
if (!f) {
if (errno == EEXIST)
log_error("Failed to create mount unit file %s, as it already exists. Duplicate entry in /etc/fstab?", unit);
else
log_error("Failed to create unit file %s: %m", unit);
return -errno;
}
fprintf(f,
"# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=%s\n",
source);
if (post && !noauto && !nofail && !automount)
fprintf(f,
"Before=%s\n",
post);
if (passno > 0) {
if (streq(where, "/")) {
lnk = strjoin(arg_dest, "/", SPECIAL_LOCAL_FS_TARGET, ".wants/", "systemd-fsck-root.service", NULL);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (symlink("systemd-fsck-root.service", lnk) < 0) {
log_error("Failed to create symlink %s: %m", lnk);
return -errno;
}
} else {
_cleanup_free_ char *fsck = NULL;
fsck = unit_name_from_path_instance("systemd-fsck", what, ".service");
if (!fsck)
return log_oom();
fprintf(f,
"Requires=%s\n"
"After=%s\n",
fsck,
fsck);
}
}
fprintf(f,
"\n"
"[Mount]\n"
"What=%s\n"
"Where=%s\n"
"Type=%s\n",
what,
where,
type);
if (!isempty(opts) &&
!streq(opts, "defaults"))
fprintf(f,
"Options=%s\n",
opts);
fflush(f);
if (ferror(f)) {
log_error("Failed to write unit file %s: %m", unit);
return -errno;
}
if (!noauto) {
if (post) {
free(lnk);
lnk = strjoin(arg_dest, "/", post, nofail || automount ? ".wants/" : ".requires/", name, NULL);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (symlink(unit, lnk) < 0) {
log_error("Failed to create symlink %s: %m", lnk);
return -errno;
}
}
}
if (automount && !path_equal(where, "/")) {
automount_name = unit_name_from_path(where, ".automount");
if (!automount_name)
return log_oom();
automount_unit = strjoin(arg_dest, "/", automount_name, NULL);
if (!automount_unit)
return log_oom();
fclose(f);
f = fopen(automount_unit, "wxe");
if (!f) {
log_error("Failed to create unit file %s: %m", automount_unit);
return -errno;
}
fprintf(f,
"# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=%s\n",
source);
if (post)
fprintf(f,
"Before= %s\n",
post);
fprintf(f,
"[Automount]\n"
"Where=%s\n",
where);
fflush(f);
if (ferror(f)) {
log_error("Failed to write unit file %s: %m", automount_unit);
return -errno;
}
free(lnk);
lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", automount_name, NULL);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (symlink(automount_unit, lnk) < 0) {
log_error("Failed to create symlink %s: %m", lnk);
return -errno;
}
}
return 0;
}
bool is_path(const Graph& graph, const IndexMap index_map)
{
std::vector <typename boost::graph_traits <Graph>::vertex_descriptor> path;
path.reserve(boost::num_vertices(graph));
return is_path(graph, index_map, path);
}
static int parse_fstab(bool initrd) {
_cleanup_endmntent_ FILE *f = NULL;
const char *fstab_path;
struct mntent *me;
int r = 0;
fstab_path = initrd ? "/sysroot/etc/fstab" : "/etc/fstab";
f = setmntent(fstab_path, "re");
if (!f) {
if (errno == ENOENT)
return 0;
log_error_errno(errno, "Failed to open %s: %m", fstab_path);
return -errno;
}
while ((me = getmntent(f))) {
_cleanup_free_ char *where = NULL, *what = NULL;
bool noauto, nofail;
int k;
if (initrd && !mount_in_initrd(me))
continue;
what = fstab_node_to_udev_node(me->mnt_fsname);
if (!what)
return log_oom();
if (is_device_path(what) && path_is_read_only_fs("sys") > 0) {
log_info("Running in a container, ignoring fstab device entry for %s.", what);
continue;
}
where = initrd ? strappend("/sysroot/", me->mnt_dir) : strdup(me->mnt_dir);
if (!where)
return log_oom();
if (is_path(where))
path_kill_slashes(where);
noauto = fstab_test_yes_no_option(me->mnt_opts, "noauto\0" "auto\0");
nofail = fstab_test_yes_no_option(me->mnt_opts, "nofail\0" "fail\0");
log_debug("Found entry what=%s where=%s type=%s nofail=%s noauto=%s",
what, where, me->mnt_type,
yes_no(noauto), yes_no(nofail));
if (streq(me->mnt_type, "swap"))
k = add_swap(what, me, noauto, nofail);
else {
bool automount;
const char *post;
automount = fstab_test_option(me->mnt_opts,
"comment=systemd.automount\0"
"x-systemd.automount\0");
if (initrd)
post = SPECIAL_INITRD_FS_TARGET;
else if (mount_in_initrd(me))
post = SPECIAL_INITRD_ROOT_FS_TARGET;
else if (mount_is_network(me))
post = SPECIAL_REMOTE_FS_TARGET;
else
post = SPECIAL_LOCAL_FS_TARGET;
k = add_mount(what,
where,
me->mnt_type,
me->mnt_opts,
me->mnt_passno,
noauto,
nofail,
automount,
post,
fstab_path);
}
if (k < 0)
r = k;
}
return r;
}
static int add_mount(
const char *what,
const char *where,
const char *fstype,
const char *opts,
int passno,
bool noauto,
bool nofail,
bool automount,
const char *post,
const char *source) {
_cleanup_free_ char
*name = NULL, *unit = NULL, *lnk = NULL,
*automount_name = NULL, *automount_unit = NULL,
*filtered = NULL;
_cleanup_fclose_ FILE *f = NULL;
int r;
assert(what);
assert(where);
assert(opts);
assert(source);
if (streq_ptr(fstype, "autofs"))
return 0;
if (!is_path(where)) {
log_warning("Mount point %s is not a valid path, ignoring.", where);
return 0;
}
if (mount_point_is_api(where) ||
mount_point_ignore(where))
return 0;
if (path_equal(where, "/")) {
/* The root disk is not an option */
automount = false;
noauto = false;
nofail = false;
}
name = unit_name_from_path(where, ".mount");
if (!name)
return log_oom();
unit = strjoin(arg_dest, "/", name, NULL);
if (!unit)
return log_oom();
f = fopen(unit, "wxe");
if (!f) {
if (errno == EEXIST)
log_error("Failed to create mount unit file %s, as it already exists. Duplicate entry in /etc/fstab?", unit);
else
log_error_errno(errno, "Failed to create unit file %s: %m", unit);
return -errno;
}
fprintf(f,
"# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=%s\n"
"Documentation=man:fstab(5) man:systemd-fstab-generator(8)\n",
source);
if (post && !noauto && !nofail && !automount)
fprintf(f, "Before=%s\n", post);
if (passno != 0) {
r = generator_write_fsck_deps(f, arg_dest, what, where, fstype);
if (r < 0)
return r;
}
fprintf(f,
"\n"
"[Mount]\n"
"What=%s\n"
"Where=%s\n",
what,
where);
if (!isempty(fstype) && !streq(fstype, "auto"))
fprintf(f, "Type=%s\n", fstype);
r = generator_write_timeouts(arg_dest, what, where, opts, &filtered);
if (r < 0)
return r;
if (!isempty(filtered) && !streq(filtered, "defaults"))
fprintf(f, "Options=%s\n", filtered);
fflush(f);
if (ferror(f))
return log_error_errno(errno, "Failed to write unit file %s: %m", unit);
if (!noauto && post) {
lnk = strjoin(arg_dest, "/", post, nofail || automount ? ".wants/" : ".requires/", name, NULL);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (symlink(unit, lnk) < 0)
return log_error_errno(errno, "Failed to create symlink %s: %m", lnk);
}
if (automount) {
automount_name = unit_name_from_path(where, ".automount");
if (!automount_name)
return log_oom();
automount_unit = strjoin(arg_dest, "/", automount_name, NULL);
if (!automount_unit)
return log_oom();
fclose(f);
f = fopen(automount_unit, "wxe");
if (!f)
return log_error_errno(errno, "Failed to create unit file %s: %m", automount_unit);
fprintf(f,
"# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=%s\n"
"Documentation=man:fstab(5) man:systemd-fstab-generator(8)\n",
source);
if (post)
fprintf(f,
"Before=%s\n",
post);
fprintf(f,
"[Automount]\n"
"Where=%s\n",
where);
fflush(f);
if (ferror(f))
return log_error_errno(errno, "Failed to write unit file %s: %m", automount_unit);
free(lnk);
lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", automount_name, NULL);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (symlink(automount_unit, lnk) < 0)
return log_error_errno(errno, "Failed to create symlink %s: %m", lnk);
}
return 0;
}
int assertion(abstract_heapt *heap) {
return is_path(heap, x, p);
}
int inv(abstract_heapt *heap) {
return is_path(heap, x, p);
}
static int add_mount(
const char *what,
const char *where,
const char *type,
const char *opts,
int passno,
bool noauto,
bool nofail,
bool automount,
bool isbind,
const char *pre,
const char *pre2,
const char *online,
const char *post,
const char *source) {
_cleanup_free_ char
*name = NULL, *unit = NULL, *lnk = NULL, *device = NULL,
*automount_name = NULL, *automount_unit = NULL;
_cleanup_fclose_ FILE *f = NULL;
int r;
assert(what);
assert(where);
assert(type);
assert(opts);
assert(source);
if (streq(type, "autofs"))
return 0;
if (!is_path(where)) {
log_warning("Mount point %s is not a valid path, ignoring.", where);
return 0;
}
if (mount_point_is_api(where) ||
mount_point_ignore(where))
return 0;
name = unit_name_from_path(where, ".mount");
if (!name)
return log_oom();
unit = strjoin(arg_dest, "/", name, NULL);
if (!unit)
return log_oom();
f = fopen(unit, "wxe");
if (!f) {
if (errno == EEXIST)
log_error("Failed to create mount unit file %s, as it already exists. Duplicate entry in /etc/fstab?", unit);
else
log_error("Failed to create unit file %s: %m", unit);
return -errno;
}
fprintf(f,
"# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=%s\n"
"DefaultDependencies=no\n",
source);
if (!path_equal(where, "/")) {
if (pre)
fprintf(f,
"After=%s\n",
pre);
if (pre2)
fprintf(f,
"After=%s\n",
pre2);
if (online)
fprintf(f,
"After=%s\n"
"Wants=%s\n",
online,
online);
fprintf(f,
"Conflicts=" SPECIAL_UMOUNT_TARGET "\n"
"Before=" SPECIAL_UMOUNT_TARGET "\n");
}
if (post && !noauto && !nofail && !automount)
fprintf(f,
"Before=%s\n",
post);
fprintf(f,
"\n"
"[Mount]\n"
"What=%s\n"
"Where=%s\n"
"Type=%s\n"
"FsckPassNo=%i\n",
what,
where,
type,
passno);
if (!isempty(opts) &&
!streq(opts, "defaults"))
fprintf(f,
"Options=%s\n",
opts);
fflush(f);
if (ferror(f)) {
log_error("Failed to write unit file %s: %m", unit);
return -errno;
}
if (!noauto) {
/* don't start network mounts automatically, we do that via ifupdown hooks for now */
if (post && !streq(post, SPECIAL_REMOTE_FS_TARGET)) {
lnk = strjoin(arg_dest, "/", post, nofail || automount ? ".wants/" : ".requires/", name, NULL);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (symlink(unit, lnk) < 0) {
log_error("Failed to create symlink %s: %m", lnk);
return -errno;
}
}
if (!isbind &&
!path_equal(where, "/")) {
r = device_name(what, &device);
if (r < 0)
return r;
if (r > 0) {
free(lnk);
lnk = strjoin(arg_dest, "/", device, ".wants/", name, NULL);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (symlink(unit, lnk) < 0) {
log_error("Failed to create symlink %s: %m", lnk);
return -errno;
}
}
}
}
if (automount && !path_equal(where, "/")) {
automount_name = unit_name_from_path(where, ".automount");
if (!name)
return log_oom();
automount_unit = strjoin(arg_dest, "/", automount_name, NULL);
if (!automount_unit)
return log_oom();
fclose(f);
f = fopen(automount_unit, "wxe");
if (!f) {
log_error("Failed to create unit file %s: %m", automount_unit);
return -errno;
}
fprintf(f,
"# Automatically generated by systemd-fstab-generator\n\n"
"[Unit]\n"
"SourcePath=%s\n"
"DefaultDependencies=no\n"
"Conflicts=" SPECIAL_UMOUNT_TARGET "\n"
"Before=" SPECIAL_UMOUNT_TARGET "\n",
source);
if (post)
fprintf(f,
"Before= %s\n",
post);
fprintf(f,
"[Automount]\n"
"Where=%s\n",
where);
fflush(f);
if (ferror(f)) {
log_error("Failed to write unit file %s: %m", automount_unit);
return -errno;
}
free(lnk);
lnk = strjoin(arg_dest, "/", post, nofail ? ".wants/" : ".requires/", automount_name, NULL);
if (!lnk)
return log_oom();
mkdir_parents_label(lnk, 0755);
if (symlink(automount_unit, lnk) < 0) {
log_error("Failed to create symlink %s: %m", lnk);
return -errno;
}
}
return 0;
}
bool is_path(const Graph& g)
{
return is_path(g, boost::get(boost::vertex_index, g));
}
static int parse_fstab(const char *prefix, bool initrd) {
_cleanup_free_ char *fstab_path = NULL;
FILE *f;
int r = 0;
struct mntent *me;
fstab_path = strjoin(strempty(prefix), "/etc/fstab", NULL);
if (!fstab_path)
return log_oom();
f = setmntent(fstab_path, "r");
if (!f) {
if (errno == ENOENT)
return 0;
log_error("Failed to open %s/etc/fstab: %m", strempty(prefix));
return -errno;
}
while ((me = getmntent(f))) {
_cleanup_free_ char *where = NULL, *what = NULL;
int k;
if (initrd && !mount_in_initrd(me))
continue;
what = fstab_node_to_udev_node(me->mnt_fsname);
where = strjoin(strempty(prefix), me->mnt_dir, NULL);
if (!what || !where) {
r = log_oom();
goto finish;
}
if (is_path(where))
path_kill_slashes(where);
log_debug("Found entry what=%s where=%s type=%s", what, where, me->mnt_type);
if (streq(me->mnt_type, "swap"))
k = add_swap(what, me);
else {
bool noauto, nofail, automount, isbind;
const char *pre, *pre2, *post, *online;
noauto = !!hasmntopt(me, "noauto");
nofail = !!hasmntopt(me, "nofail");
automount =
hasmntopt(me, "comment=systemd.automount") ||
hasmntopt(me, "x-systemd.automount");
isbind = mount_is_bind(me);
if (initrd) {
pre = pre2 = online = NULL;
post = SPECIAL_INITRD_FS_TARGET;
} else if (mount_in_initrd(me)) {
pre = pre2 = online = NULL;
post = SPECIAL_INITRD_ROOT_FS_TARGET;
} else if (mount_is_network(me)) {
pre = SPECIAL_REMOTE_FS_PRE_TARGET;
pre2 = SPECIAL_NETWORK_TARGET;
online = SPECIAL_NETWORK_ONLINE_TARGET;
post = SPECIAL_REMOTE_FS_TARGET;
} else {
pre = SPECIAL_LOCAL_FS_PRE_TARGET;
pre2 = online = NULL;
post = SPECIAL_LOCAL_FS_TARGET;
}
k = add_mount(what, where, me->mnt_type, me->mnt_opts,
me->mnt_passno, noauto, nofail, automount,
isbind, pre, pre2, online, post, fstab_path);
}
if (k < 0)
r = k;
}
finish:
endmntent(f);
return r;
}
void update_hpvol(bool with_fade)
{
unsigned short val;
unsigned short i;
short steps;
int hp_level_old[2];
unsigned short hp_level_registers[2] = { WM8994_LEFT_OUTPUT_VOLUME,
WM8994_RIGHT_OUTPUT_VOLUME };
DECLARE_WM8994(codec);
// don't affect headphone amplifier volume
// when not on heapdhones or if call is active
if (!is_path(HEADPHONES)
|| (wm8994->codec_state & CALL_ACTIVE))
return;
if (!with_fade) {
bypass_write_extension = true;
write_hpvol(hpvol(0), hpvol(1));
bypass_write_extension = false;
return;
}
// read previous levels
for (i = 0; i < 2; i++) {
val = wm8994_read(codec, hp_level_registers[i]);
val &= ~(WM8994_HPOUT1_VU_MASK);
val &= ~(WM8994_HPOUT1L_ZC_MASK);
val &= ~(WM8994_HPOUT1L_MUTE_N_MASK);
hp_level_old[i] = val + (digital_gain / 1000);
if (hp_level_old[i] < 0)
hp_level_old[i] = 0;
if (debug_log(LOG_INFOS))
printk("wm8994_extensions: previous hp_level[%hu]: %d\n",
i, hp_level_old[i]);
}
// calculate number of steps for volume fade
steps = hp_level[0] - hp_level_old[0];
if (debug_log(LOG_INFOS))
printk("wm8994_extensions: volume change steps: %hd "
"start: %hu, end: %hu\n",
steps,
hp_level_old[0],
hp_level[0]);
while (steps != 0) {
if (hp_level[0] < hp_level_old[0])
steps++;
else
steps--;
if (debug_log(LOG_INFOS))
printk("wm8994_extensions: volume: %hu\n",
(hpvol(0) - steps));
bypass_write_extension = true;
write_hpvol(hpvol(0) - steps, hpvol(1) - steps);
bypass_write_extension = false;
if (steps != 0)
udelay(1000);
}
}
int assertion(abstract_heapt *heap) {
return is_path(heap, x, null_ptr);
}
bool
is_rooted_path (url u) {
return is_rooted (u) && is_path (u);
}
